<artifactId>mappingservice.api</artifactId>
<version>${project.version}</version>
</dependency>
- <!--
<dependency>
<groupId>${project.groupId}</groupId>
<artifactId>mappingservice.implementation</artifactId>
<artifactId>mappingservice.southbound</artifactId>
<version>${project.version}</version>
</dependency>
- -->
<dependency>
<groupId>${project.groupId}</groupId>
<artifactId>mappingservice.lisp-proto</artifactId>
<version>${project.version}</version>
</dependency>
- <!--
<dependency>
<groupId>${project.groupId}</groupId>
<artifactId>lispflowmapping-ui-bundle</artifactId>
<version>${project.version}</version>
</dependency>
- -->
<dependency>
<groupId>${project.groupId}</groupId>
<artifactId>features-lispflowmapping</artifactId>
</prerequisites>
<properties>
- <!-- <karaf.localFeature>odl-lispflowmapping-msmr</karaf.localFeature> -->
- <karaf.localFeature>odl-lispflowmapping-models</karaf.localFeature>
+ <karaf.localFeature>odl-lispflowmapping-msmr</karaf.localFeature>
</properties>
<dependencyManagement>
<type>xml</type>
<scope>runtime</scope>
</dependency>
- <!--
<dependency>
<groupId>${project.groupId}</groupId>
<artifactId>mappingservice.implementation</artifactId>
<classifier>config</classifier>
<type>xml</type>
</dependency>
- -->
<dependency>
<groupId>${project.groupId}</groupId>
<artifactId>mappingservice.api</artifactId>
<version>${project.version}</version>
</dependency>
- <!--
<dependency>
<groupId>${project.groupId}</groupId>
<artifactId>mappingservice.inmemorydb</artifactId>
<artifactId>mappingservice.shell</artifactId>
<version>${project.version}</version>
</dependency>
- -->
<dependency>
<groupId>${project.groupId}</groupId>
<artifactId>mappingservice.lisp-proto</artifactId>
<version>${project.version}</version>
</dependency>
- <!--
<dependency>
<groupId>${project.groupId}</groupId>
<artifactId>lispflowmapping-ui-bundle</artifactId>
<classifier>features</classifier>
<type>xml</type>
</dependency>
- -->
</dependencies>
</project>
<repository>mvn:org.opendaylight.netconf/features-restconf/{{VERSION}}/xml/features</repository>
<!-- Needed for odl-config-api -->
<repository>mvn:org.opendaylight.controller/features-config/{{VERSION}}/xml/features</repository>
- <!--
<repository>mvn:org.opendaylight.neutron/features-neutron/{{VERSION}}/xml/features</repository>
<repository>mvn:org.opendaylight.dlux/features-dlux/{{VERSION}}/xml/features</repository>
- -->
- <!--
<feature name="odl-lispflowmapping-msmr" description="OpenDaylight :: LISP Flow Mapping :: Map-Server/Map-Resolver" version='${project.version}'>
<feature version="${project.version}">odl-lispflowmapping-mappingservice</feature>
<feature version="${project.version}">odl-lispflowmapping-southbound</feature>
<feature version="${project.version}">odl-lispflowmapping-mappingservice</feature>
<bundle>mvn:org.opendaylight.lispflowmapping/lispflowmapping-ui-bundle/{{VERSION}}</bundle>
</feature>
- -->
<feature name="odl-lispflowmapping-models" description="OpenDaylight :: LISP Flow Mapping :: Models" version='${project.version}'>
<feature version='${config.version}'>odl-config-api</feature>
<artifactId>org.eclipse.osgi</artifactId>
</dependency>
</dependencies>
+
+ <build>
+ <!-- Temporarily disable compiling non-generated code, like serializers, which won't build for now -->
+ <plugins>
+ <plugin>
+ <artifactId>maven-compiler-plugin</artifactId>
+ <executions>
+ <execution>
+ <id>default-testCompile</id>
+ <phase>test-compile</phase>
+ <goals>
+ <goal>testCompile</goal>
+ </goals>
+ <configuration>
+ <skip>true</skip>
+ </configuration>
+ </execution>
+ </executions>
+ </plugin>
+ </plugins>
+ </build>
</project>
+++ /dev/null
-package org.opendaylight.controller.config.yang.config.lfm.mappingservice.shell.impl;
-
-import org.opendaylight.lispflowmapping.implementation.MappingServiceShell;
-
-public class MappingServiceShellModule extends org.opendaylight.controller.config.yang.config.lfm.mappingservice.shell.impl.AbstractMappingServiceShellModule {
- private MappingServiceShell mappingServiceShell;
-
- public MappingServiceShellModule(org.opendaylight.controller.config.api.ModuleIdentifier identifier, org.opendaylight.controller.config.api.DependencyResolver dependencyResolver) {
- super(identifier, dependencyResolver);
- }
-
- public MappingServiceShellModule(org.opendaylight.controller.config.api.ModuleIdentifier identifier, org.opendaylight.controller.config.api.DependencyResolver dependencyResolver, org.opendaylight.controller.config.yang.config.lfm.mappingservice.shell.impl.MappingServiceShellModule oldModule, java.lang.AutoCloseable oldInstance) {
- super(identifier, dependencyResolver, oldModule, oldInstance);
- }
-
- @Override
- public void customValidation() {
- // add custom validation form module attributes here.
- }
-
- @Override
- public java.lang.AutoCloseable createInstance() {
- mappingServiceShell = new MappingServiceShell();
- mappingServiceShell.setBindingAwareBroker(getBrokerDependency());
- mappingServiceShell.setMappingService(getMappingserviceDependency());
- return mappingServiceShell;
- }
-
-}
+++ /dev/null
-/*
-* Generated file
-*
-* Generated from: yang module name: mappingservice-shell-impl yang module local name: mappingservice-shell-impl
-* Generated by: org.opendaylight.controller.config.yangjmxgenerator.plugin.JMXGenerator
-* Generated at: Fri Sep 25 12:24:36 CEST 2015
-*
-* Do not modify this file unless it is present under src/main directory
-*/
-package org.opendaylight.controller.config.yang.config.lfm.mappingservice.shell.impl;
-public class MappingServiceShellModuleFactory extends org.opendaylight.controller.config.yang.config.lfm.mappingservice.shell.impl.AbstractMappingServiceShellModuleFactory {
-
-}
import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.AddMapping;
import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.GotMapNotify;
import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.GotMapReply;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.LispProtoListener;
import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.MapNotify;
import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.MapRegister;
import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.MapReply;
import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.MapRequest;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.OdlLispProtoListener;
import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.RequestMapping;
import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.XtrReplyMapping;
import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.XtrRequestMapping;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.lispaddress.LispAddressContainer;
import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.mapnotifymessage.MapNotifyBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.mapreplymessage.MapReplyBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.maprequestmessage.MapRequestBuilder;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.transportaddress.TransportAddress;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.transportaddress.TransportAddressBuilder;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.sb.rev150904.LispSbService;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.rloc.container.Rloc;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.transport.address.TransportAddress;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.transport.address.TransportAddressBuilder;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.sb.rev150904.OdlLispSbService;
import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.sb.rev150904.SendMapNotifyInputBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.sb.rev150904.SendMapReplyInputBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.sb.rev150904.SendMapRequestInputBuilder;
import org.slf4j.LoggerFactory;
public class LispMappingService implements IFlowMapping, BindingAwareProvider, IMapRequestResultHandler,
- IMapNotifyHandler, LispProtoListener, AutoCloseable {
+ IMapNotifyHandler, OdlLispProtoListener, AutoCloseable {
protected static final Logger LOG = LoggerFactory.getLogger(LispMappingService.class);
private volatile boolean shouldAuthenticate = true;
private ThreadLocal<MapNotify> tlsMapNotify = new ThreadLocal<MapNotify>();
private ThreadLocal<Pair<MapRequest, TransportAddress>> tlsMapRequest = new ThreadLocal<Pair<MapRequest, TransportAddress>>();
- private LispSbService lispSB = null;
+ private OdlLispSbService lispSB = null;
private IMapResolverAsync mapResolver;
private IMapServerAsync mapServer;
public MapReply handleMapRequest(MapRequest request) {
LOG.debug("DAO: Retrieving mapping for {}",
- LispAddressStringifier.getString(request.getEidRecord().get(0).getLispAddressContainer()));
+ LispAddressStringifier.getString(request.getEidItem().get(0).getEid()));
tlsMapReply.set(null);
tlsMapRequest.set(null);
public MapNotify handleMapRegister(MapRegister mapRegister) {
LOG.debug("DAO: Adding mapping for {}",
- LispAddressStringifier.getString(mapRegister.getEidToLocatorRecord().get(0).getLispAddressContainer()));
+ LispAddressStringifier.getString(mapRegister.getMappingRecordItem().get(0)
+ .getMappingRecord().getEid()));
tlsMapNotify.set(null);
mapServer.handleMapRegister(mapRegister);
public MapNotify handleMapRegister(MapRegister mapRegister, boolean smr) {
LOG.debug("DAO: Adding mapping for {}",
- LispAddressStringifier.getString(mapRegister.getEidToLocatorRecord().get(0).getLispAddressContainer()));
+ LispAddressStringifier.getString(mapRegister.getMappingRecordItem().get(0)
+ .getMappingRecord().getEid()));
tlsMapNotify.set(null);
mapServer.handleMapRegister(mapRegister);
LOG.debug("Received XtrReplyMapping notification, ignoring");
}
- private LispSbService getLispSB() {
+ private OdlLispSbService getLispSB() {
if (lispSB == null) {
- lispSB = session.getRpcService(LispSbService.class);
+ lispSB = session.getRpcService(OdlLispSbService.class);
}
return lispSB;
}
}
@Override
- public void handleSMR(MapRequest smr, LispAddressContainer subscriber) {
+ public void handleSMR(MapRequest smr, Rloc subscriber) {
LOG.debug("Sending SMR to {} with Source-EID {} and EID Record {}",
LispAddressStringifier.getString(subscriber),
- LispAddressStringifier.getString(smr.getSourceEid().getLispAddressContainer()),
- LispAddressStringifier.getString(smr.getEidRecord().get(0).getLispAddressContainer()));
+ LispAddressStringifier.getString(smr.getSourceEid().getEid()),
+ LispAddressStringifier.getString(smr.getEidItem().get(0).getEid()));
SendMapRequestInputBuilder smrib = new SendMapRequestInputBuilder();
smrib.setMapRequest(new MapRequestBuilder(smr).build());
- smrib.setTransportAddress(LispNotificationHelper.getTransportAddressFromContainer(subscriber));
+ smrib.setTransportAddress(LispNotificationHelper.getTransportAddressFromRloc(subscriber));
getLispSB().sendMapRequest(smrib.build());
}
*/
package org.opendaylight.lispflowmapping.implementation;
-import java.util.Arrays;
import java.util.concurrent.Future;
import org.opendaylight.controller.md.sal.binding.api.DataBroker;
import org.opendaylight.lispflowmapping.implementation.util.RPCInputConvertorUtil;
import org.opendaylight.lispflowmapping.interfaces.dao.ILispDAO;
import org.opendaylight.lispflowmapping.interfaces.mappingservice.IMappingService;
-import org.opendaylight.lispflowmapping.lisp.util.MaskUtil;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.eidtolocatorrecords.EidToLocatorRecord;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.lispaddress.LispAddressContainer;
+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.mappingservice.rev150906.AddKeyInput;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.mappingservice.rev150906.AddKeyInputBuilder;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.mappingservice.rev150906.AddKeysInput;
import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.mappingservice.rev150906.AddMappingInput;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.mappingservice.rev150906.AddMappingInputBuilder;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.mappingservice.rev150906.AddMappingsInput;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.mappingservice.rev150906.GetAllKeysOutput;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.mappingservice.rev150906.GetAllMappingsOutput;
import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.mappingservice.rev150906.GetKeyInput;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.mappingservice.rev150906.GetKeyInputBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.mappingservice.rev150906.GetKeyOutput;
import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.mappingservice.rev150906.GetKeyOutputBuilder;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.mappingservice.rev150906.GetKeysInput;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.mappingservice.rev150906.GetKeysOutput;
import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.mappingservice.rev150906.GetMappingInput;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.mappingservice.rev150906.GetMappingInputBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.mappingservice.rev150906.GetMappingOutput;
import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.mappingservice.rev150906.GetMappingOutputBuilder;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.mappingservice.rev150906.GetMappingsInput;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.mappingservice.rev150906.GetMappingsOutput;
import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.mappingservice.rev150906.MappingOrigin;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.mappingservice.rev150906.MappingserviceService;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.mappingservice.rev150906.OdlMappingserviceService;
import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.mappingservice.rev150906.RemoveKeyInput;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.mappingservice.rev150906.RemoveKeyInputBuilder;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.mappingservice.rev150906.RemoveKeysInput;
import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.mappingservice.rev150906.RemoveMappingInput;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.mappingservice.rev150906.RemoveMappingInputBuilder;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.mappingservice.rev150906.RemoveMappingsInput;
import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.mappingservice.rev150906.SiteId;
import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.mappingservice.rev150906.UpdateKeyInput;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.mappingservice.rev150906.UpdateKeyInputBuilder;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.mappingservice.rev150906.UpdateKeysInput;
import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.mappingservice.rev150906.UpdateMappingInput;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.mappingservice.rev150906.UpdateMappingInputBuilder;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.mappingservice.rev150906.update.key.input.EidBuilder;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.mappingservice.rev150906.UpdateMappingsInput;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.mappingservice.rev150906.mapping.authkey.container.MappingAuthkey;
import org.opendaylight.yangtools.yang.common.RpcError;
import org.opendaylight.yangtools.yang.common.RpcResult;
import org.opendaylight.yangtools.yang.common.RpcResultBuilder;
* @author Florin Coras
*
*/
-public class MappingService implements MappingserviceService, IMappingService, BindingAwareProvider, AutoCloseable {
+public class MappingService implements OdlMappingserviceService, IMappingService, BindingAwareProvider, AutoCloseable {
protected static final Logger LOG = LoggerFactory.getLogger(MappingService.class);
private static final String NOT_FOUND_TAG = "data-missing";
private static final String DATA_EXISTS_TAG = "data-exists";
private MappingSystem mappingSystem;
private DataStoreBackEnd dsbe;
- private RpcRegistration<MappingserviceService> mappingServiceRpc;
+ private RpcRegistration<OdlMappingserviceService> mappingServiceRpc;
private AuthenticationKeyDataListener keyListener;
private MappingDataListener mappingListener;
private ILispDAO dao;
public void initialize() {
bindingAwareBroker.registerProvider(this);
- mappingServiceRpc = rpcRegistry.addRpcImplementation(MappingserviceService.class, this);
+ mappingServiceRpc = rpcRegistry.addRpcImplementation(OdlMappingserviceService.class, this);
dsbe = new DataStoreBackEnd(dataBroker);
mappingSystem = new MappingSystem(dao, iterateMask, notificationPolicy, overwritePolicy);
RpcResultBuilder<Void> rpcResultBuilder;
- // XXX: to remove once RPC API has been updated to remove explicit mask
- input = new AddKeyInputBuilder(input).setLispAddressContainer(
- MaskUtil.fixMask(input.getLispAddressContainer(), input.getMaskLength())).build();
-
- String key = mappingSystem.getAuthenticationKey(input.getLispAddressContainer());
+ MappingAuthkey key = mappingSystem.getAuthenticationKey(input.getEid());
if (key != null) {
String message = "Key already exists! Please use update-key if you want to change it.";
Preconditions.checkNotNull(input, "add-mapping RPC input must be not null!");
LOG.trace("RPC received to add the following mapping: " + input.toString());
- // XXX: to remove once RPC API has been updated to remove explicit mask
- input = new AddMappingInputBuilder(input).setLispAddressContainer(
- MaskUtil.fixMask(input.getLispAddressContainer(), input.getMaskLength())).build();
-
dsbe.addMapping(RPCInputConvertorUtil.toMapping(input));
RpcResultBuilder<Void> rpcResultBuilder;
Preconditions.checkNotNull(input, "get-key RPC input must be not null!");
LOG.trace("RPC received to get the following key: " + input.toString());
- // XXX: to remove once RPC API has been updated to remove explicit mask
- input = new GetKeyInputBuilder(input).setLispAddressContainer(
- MaskUtil.fixMask(input.getLispAddressContainer(), input.getMaskLength())).build();
-
RpcResultBuilder<GetKeyOutput> rpcResultBuilder;
- String key = mappingSystem.getAuthenticationKey(input.getLispAddressContainer());
+ MappingAuthkey key = mappingSystem.getAuthenticationKey(input.getEid());
if (key == null) {
String message = "Key was not found in the mapping database";
rpcResultBuilder = RpcResultBuilder.<GetKeyOutput>failed()
.withError(RpcError.ErrorType.APPLICATION, NOT_FOUND_TAG, message);
} else {
- rpcResultBuilder = RpcResultBuilder.success(new GetKeyOutputBuilder().setAuthkey(key));
+ rpcResultBuilder = RpcResultBuilder.success(new GetKeyOutputBuilder().setMappingAuthkey(key));
}
return Futures.immediateFuture(rpcResultBuilder.build());
Preconditions.checkNotNull(input, "get-mapping RPC input must be not null!");
LOG.trace("RPC received to get the following mapping: " + input.toString());
- // XXX: to remove once RPC API has been updated to remove explicit mask
- input = new GetMappingInputBuilder(input).setLispAddressContainer(
- MaskUtil.fixMask(input.getLispAddressContainer(), input.getMaskLength())).build();
-
RpcResultBuilder<GetMappingOutput> rpcResultBuilder;
- EidToLocatorRecord reply = (EidToLocatorRecord) mappingSystem.getMapping(input.getLispAddressContainer());
+ MappingRecord reply = (MappingRecord) mappingSystem.getMapping(input.getEid());
if (reply == null) {
String message = "No mapping was found in the mapping database";
rpcResultBuilder = RpcResultBuilder.<GetMappingOutput>failed()
.withError(RpcError.ErrorType.APPLICATION, NOT_FOUND_TAG, message);
} else {
- rpcResultBuilder = RpcResultBuilder.success(new GetMappingOutputBuilder().setEidToLocatorRecord(Arrays
- .asList(reply)));
+ rpcResultBuilder = RpcResultBuilder.success(new GetMappingOutputBuilder().setMappingRecord(reply));
}
return Futures.immediateFuture(rpcResultBuilder.build());
Preconditions.checkNotNull(input, "remove-key RPC input must be not null!");
LOG.trace("RPC received to remove the following key: " + input.toString());
- // XXX: to remove once RPC API has been updated to remove explicit mask
- input = new RemoveKeyInputBuilder(input).setLispAddressContainer(
- MaskUtil.fixMask(input.getLispAddressContainer(), input.getMaskLength())).build();
-
RpcResultBuilder<Void> rpcResultBuilder;
dsbe.removeAuthenticationKey(RPCInputConvertorUtil.toAuthenticationKey(input));
Preconditions.checkNotNull(input, "remove-mapping RPC input must be not null!");
LOG.trace("RPC received to remove the following mapping: " + input.toString());
- // XXX: to remove once RPC API has been updated to remove explicit mask
- input = new RemoveMappingInputBuilder(input).setLispAddressContainer(
- MaskUtil.fixMask(input.getLispAddressContainer(), input.getMaskLength())).build();
-
RpcResultBuilder<Void> rpcResultBuilder;
dsbe.removeMapping(RPCInputConvertorUtil.toMapping(input));
Preconditions.checkNotNull(input, "update-key RPC input must be not null!");
LOG.trace("RPC received to update the following key: " + input.toString());
- // XXX: to remove once RPC API has been updated to remove explicit mask
- input = new UpdateKeyInputBuilder(input).setEid(
- new EidBuilder(input.getEid()).setLispAddressContainer(
- MaskUtil.fixMask(input.getEid().getLispAddressContainer(), input.getEid()
- .getMaskLength())).build()).build();
-
RpcResultBuilder<Void> rpcResultBuilder;
- String key = mappingSystem.getAuthenticationKey(input.getEid().getLispAddressContainer());
+ MappingAuthkey key = mappingSystem.getAuthenticationKey(input.getEid());
if (key == null) {
String message = "Key doesn't exist! Please use add-key if you want to create a new authentication key.";
LOG.trace("RPC received to update the following mapping: " + input.toString());
Preconditions.checkNotNull(input, "update-mapping RPC input must be not null!");
- // XXX: to remove once RPC API has been updated to remove explicit mask
- input = new UpdateMappingInputBuilder(input).setLispAddressContainer(
- MaskUtil.fixMask(input.getLispAddressContainer(), input.getMaskLength())).build();
-
RpcResultBuilder<Void> rpcResultBuilder;
dsbe.updateMapping(RPCInputConvertorUtil.toMapping(input));
}
@Override
- public void addMapping(MappingOrigin origin, LispAddressContainer key, SiteId siteId, Object data) {
- dsbe.addMapping(DSBEInputUtil.toMapping(origin, key, siteId, (EidToLocatorRecord) data));
+ public Future<RpcResult<Void>> removeKeys(RemoveKeysInput input) {
+ // TODO Auto-generated method stub
+ return null;
+ }
+
+ @Override
+ public Future<RpcResult<Void>> removeMappings(RemoveMappingsInput input) {
+ // TODO Auto-generated method stub
+ return null;
+ }
+
+ @Override
+ public Future<RpcResult<GetKeysOutput>> getKeys(GetKeysInput input) {
+ // TODO Auto-generated method stub
+ return null;
+ }
+
+ @Override
+ public Future<RpcResult<Void>> addMappings(AddMappingsInput input) {
+ // TODO Auto-generated method stub
+ return null;
+ }
+
+ @Override
+ public Future<RpcResult<Void>> updateKeys(UpdateKeysInput input) {
+ // TODO Auto-generated method stub
+ return null;
+ }
+
+ @Override
+ public Future<RpcResult<Void>> removeAllMappings() {
+ // TODO Auto-generated method stub
+ return null;
+ }
+
+ @Override
+ public Future<RpcResult<Void>> removeAllKeys() {
+ // TODO Auto-generated method stub
+ return null;
+ }
+
+ @Override
+ public Future<RpcResult<GetAllKeysOutput>> getAllKeys() {
+ // TODO Auto-generated method stub
+ return null;
+ }
+
+ @Override
+ public Future<RpcResult<Void>> updateMappings(UpdateMappingsInput input) {
+ // TODO Auto-generated method stub
+ return null;
+ }
+
+ @Override
+ public Future<RpcResult<Void>> addKeys(AddKeysInput input) {
+ // TODO Auto-generated method stub
+ return null;
+ }
+
+ @Override
+ public Future<RpcResult<GetAllMappingsOutput>> getAllMappings() {
+ // TODO Auto-generated method stub
+ return null;
+ }
+
+ @Override
+ public Future<RpcResult<GetMappingsOutput>> getMappings(
+ GetMappingsInput input) {
+ // TODO Auto-generated method stub
+ return null;
+ }
+
+ @Override
+ public void addMapping(MappingOrigin origin, Eid key, SiteId siteId, Object data) {
+ dsbe.addMapping(DSBEInputUtil.toMapping(origin, key, siteId, (MappingRecord) data));
mappingSystem.updateMappingRegistration(origin, key);
}
@Override
- public Object getMapping(MappingOrigin origin, LispAddressContainer key) {
+ public Object getMapping(MappingOrigin origin, Eid key) {
return mappingSystem.getMapping(origin, key);
}
@Override
- public Object getMapping(LispAddressContainer key) {
+ public Object getMapping(Eid key) {
return mappingSystem.getMapping(key);
}
@Override
- public Object getMapping(LispAddressContainer srcKey, LispAddressContainer dstKey) {
+ public Object getMapping(Eid srcKey, Eid dstKey) {
return mappingSystem.getMapping(srcKey, dstKey);
}
@Override
- public void removeMapping(MappingOrigin origin, LispAddressContainer key) {
+ public void removeMapping(MappingOrigin origin, Eid key) {
dsbe.removeMapping(DSBEInputUtil.toMapping(origin, key));
}
@Override
- public void addAuthenticationKey(LispAddressContainer key, String authKey) {
+ public void addAuthenticationKey(Eid key, MappingAuthkey authKey) {
dsbe.addAuthenticationKey(DSBEInputUtil.toAuthenticationKey(key, authKey));
}
@Override
- public String getAuthenticationKey(LispAddressContainer key) {
+ public MappingAuthkey getAuthenticationKey(Eid key) {
return mappingSystem.getAuthenticationKey(key);
}
@Override
- public void removeAuthenticationKey(LispAddressContainer key) {
+ public void removeAuthenticationKey(Eid key) {
dsbe.removeAuthenticationKey(DSBEInputUtil.toAuthenticationKey(key, null));
}
@Override
- public void addData(MappingOrigin origin, LispAddressContainer key, String subKey, Object data) {
+ public void addData(MappingOrigin origin, Eid key, String subKey, Object data) {
mappingSystem.addData(origin, key, subKey, data);
}
@Override
- public Object getData(MappingOrigin origin, LispAddressContainer key, String subKey) {
+ public Object getData(MappingOrigin origin, Eid key, String subKey) {
return mappingSystem.getData(origin, key, subKey);
}
@Override
- public void removeData(MappingOrigin origin, LispAddressContainer key, String subKey) {
+ public void removeData(MappingOrigin origin, Eid key, String subKey) {
mappingSystem.removeData(origin, key, subKey);
}
import org.opendaylight.controller.sal.binding.api.BindingAwareProvider;
import org.opendaylight.lispflowmapping.interfaces.mappingservice.IMappingService;
import org.opendaylight.lispflowmapping.interfaces.mappingservice.IMappingServiceShell;
-import org.opendaylight.lispflowmapping.lisp.util.LispAFIConvertor;
-import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev100924.Ipv4Address;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.lispaddress.LispAddressContainer;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.lispaddress.lispaddresscontainer.address.ipv4.Ipv4AddressBuilder;
+import org.opendaylight.lispflowmapping.lisp.util.LispAddressUtil;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev100924.Ipv4Prefix;
+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.mapping.authkey.container.MappingAuthkey;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.mappingservice.rev150906.mapping.authkey.container.MappingAuthkeyBuilder;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
@Override
public void addDefaultKeyIPv4() {
- LispAddressContainer address = LispAFIConvertor.toContainer(
- new Ipv4AddressBuilder().setIpv4Address(new Ipv4Address("0.0.0.0")).setMask((short)0).build());
- mappingService.addAuthenticationKey(address, "password");
+ Eid eid = LispAddressUtil.toEid(new Ipv4Prefix("0.0.0.0/0"), null);
+ MappingAuthkey key = new MappingAuthkeyBuilder().setKeyType(1).setKeyString("password").build();
+ mappingService.addAuthenticationKey(eid, key);
}
@Override
import org.opendaylight.lispflowmapping.interfaces.mapcache.IMapCache;
import org.opendaylight.lispflowmapping.interfaces.mapcache.IMappingSystem;
import org.opendaylight.lispflowmapping.lisp.util.LispAddressStringifier;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.eidtolocatorrecords.EidToLocatorRecordBuilder;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.lispaddress.LispAddressContainer;
+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.MappingOrigin;
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.Mapping;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.mappingservice.rev150906.mapping.authkey.container.MappingAuthkey;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
tableMap.put(MappingOrigin.Southbound, smc);
}
- public void addMapping(MappingOrigin origin, LispAddressContainer key, Object value) {
+ public void addMapping(MappingOrigin origin, Eid key, Object value) {
tableMap.get(origin).addMapping(key, value, overwrite);
}
- public void updateMappingRegistration(MappingOrigin origin, LispAddressContainer key) {
+ public void updateMappingRegistration(MappingOrigin origin, Eid key) {
tableMap.get(origin).updateMappingRegistration(key);
}
@Override
- public Object getMapping(LispAddressContainer src, LispAddressContainer dst) {
+ public Object getMapping(Eid src, Eid dst) {
// NOTE: what follows is just a simple implementation of a lookup logic, it SHOULD be subject to future
// improvements
}
@Override
- public Object getMapping(LispAddressContainer dst) {
- return getMapping((LispAddressContainer)null, dst);
+ public Object getMapping(Eid dst) {
+ return getMapping((Eid)null, dst);
}
@Override
- public Object getMapping(MappingOrigin origin, LispAddressContainer key) {
+ public Object getMapping(MappingOrigin origin, Eid key) {
return tableMap.get(origin).getMapping(null, key);
}
@Override
- public void removeMapping(MappingOrigin origin, LispAddressContainer key) {
+ public void removeMapping(MappingOrigin origin, Eid key) {
tableMap.get(origin).removeMapping(key, overwrite);
if (notificationService) {
// TODO
}
@Override
- public void addAuthenticationKey(LispAddressContainer key, String authKey) {
+ public void addAuthenticationKey(Eid key, MappingAuthkey authKey) {
LOG.debug("Adding authentication key '{}' for {}", key,
LispAddressStringifier.getString(key));
smc.addAuthenticationKey(key, authKey);
}
@Override
- public String getAuthenticationKey(LispAddressContainer key) {
+ public MappingAuthkey getAuthenticationKey(Eid key) {
LOG.debug("Retrieving authentication key for {}", LispAddressStringifier.getString(key));
return smc.getAuthenticationKey(key);
}
@Override
- public void removeAuthenticationKey(LispAddressContainer key) {
+ public void removeAuthenticationKey(Eid key) {
LOG.debug("Removing authentication key for {}", LispAddressStringifier.getString(key));
smc.removeAuthenticationKey(key);
}
@Override
- public void addData(MappingOrigin origin, LispAddressContainer key, String subKey, Object data) {
+ public void addData(MappingOrigin origin, Eid key, String subKey, Object data) {
LOG.debug("Add data of class {} for key {} and subkey {}", data.getClass(),
LispAddressStringifier.getString(key), subKey);
tableMap.get(origin).addData(key, subKey, data);
}
@Override
- public Object getData(MappingOrigin origin, LispAddressContainer key, String subKey) {
+ public Object getData(MappingOrigin origin, Eid key, String subKey) {
LOG.debug("Retrieving data for key {} and subkey {}", LispAddressStringifier.getString(key), subKey);
return tableMap.get(origin).getData(key, subKey);
}
@Override
- public void removeData(MappingOrigin origin, LispAddressContainer key, String subKey) {
+ public void removeData(MappingOrigin origin, Eid key, String subKey) {
LOG.debug("Removing data for key {} and subkey {}", LispAddressStringifier.getString(key), subKey);
tableMap.get(origin).removeData(key, subKey);
}
LOG.info("Restoring {} mappings and {} keys from datastore into DAO", mappings.size(), authKeys.size());
for (Mapping mapping : mappings) {
- addMapping(mapping.getOrigin(), mapping.getLispAddressContainer(),
- new EidToLocatorRecordBuilder(mapping).build());
+ addMapping(mapping.getOrigin(), mapping.getMappingRecord().getEid(), mapping.getMappingRecord());
}
for (AuthenticationKey authKey : authKeys) {
- addAuthenticationKey(authKey.getLispAddressContainer(), authKey.getAuthkey());
+ addAuthenticationKey(authKey.getEid(), authKey.getMappingAuthkey());
}
}
import org.opendaylight.lispflowmapping.interfaces.lisp.IMapRequestResultHandler;
import org.opendaylight.lispflowmapping.interfaces.lisp.IMapResolverAsync;
import org.opendaylight.lispflowmapping.interfaces.mappingservice.IMappingService;
-import org.opendaylight.lispflowmapping.lisp.util.LcafSourceDestHelper;
-import org.opendaylight.lispflowmapping.lisp.util.LispAFIConvertor;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.EidToLocatorRecord.Action;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.LcafTrafficEngineeringAddress;
+import org.opendaylight.lispflowmapping.lisp.util.LispAddressUtil;
+import org.opendaylight.lispflowmapping.lisp.util.SourceDestKeyHelper;
+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.SourceDestKey;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.lisp.address.types.rev151105.lisp.address.address.explicit.locator.path.explicit.locator.path.Hop;
import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.MapRequest;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.eidrecords.EidRecord;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.eidtolocatorrecords.EidToLocatorRecord;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.eidtolocatorrecords.EidToLocatorRecordBuilder;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.lcaftrafficengineeringaddress.Hops;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.lispaddress.LispAddressContainer;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.lispaddress.lispaddresscontainer.address.LcafSourceDest;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.lispaddress.lispaddresscontainer.address.LcafTrafficEngineering;
+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.eid.list.EidItem;
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;
+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.MappingRecord.Action;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.mapping.record.container.MappingRecordBuilder;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.mapping.record.list.MappingRecordItem;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.mapping.record.list.MappingRecordItemBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.mapreplymessage.MapReplyBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.maprequest.ItrRloc;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.rloc.container.Rloc;
import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.mappingservice.rev150906.MappingOrigin;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
}
public void handleMapRequest(MapRequest request) {
- LispAddressContainer srcEid = null;
+ Eid srcEid = null;
if (request.getSourceEid() != null) {
- srcEid = request.getSourceEid().getLispAddressContainer();
+ srcEid = request.getSourceEid().getEid();
}
MapReplyBuilder replyBuilder = new MapReplyBuilder();
replyBuilder.setEchoNonceEnabled(false);
replyBuilder.setProbe(false);
replyBuilder.setSecurityEnabled(false);
replyBuilder.setNonce(request.getNonce());
- replyBuilder.setEidToLocatorRecord(new ArrayList<EidToLocatorRecord>());
- for (EidRecord eidRecord : request.getEidRecord()) {
- EidToLocatorRecord mapping = (EidToLocatorRecord) mapService.getMapping(srcEid,
- eidRecord.getLispAddressContainer());
+ replyBuilder.setMappingRecordItem(new ArrayList<MappingRecordItem>());
+ for (EidItem eidRecord : request.getEidItem()) {
+ MappingRecord mapping = (MappingRecord) mapService.getMapping(srcEid,
+ eidRecord.getEid());
if (mapping != null) {
List<ItrRloc> itrRlocs = request.getItrRloc();
if (itrRlocs != null && itrRlocs.size() != 0) {
if (subscriptionService) {
- updateSubscribers(itrRlocs.get(0).getLispAddressContainer(), mapping.getLispAddressContainer(),
+ updateSubscribers(itrRlocs.get(0).getRloc(), mapping.getEid(),
srcEid);
}
mapping = updateLocators(mapping, itrRlocs);
}
- mapping = fixIfNotSDRequest(mapping, eidRecord.getLispAddressContainer());
+ mapping = fixIfNotSDRequest(mapping, eidRecord.getEid());
} else {
- mapping = getNegativeMapping(eidRecord.getLispAddressContainer(), eidRecord.getMask());
+ mapping = getNegativeMapping(eidRecord.getEid());
}
- replyBuilder.getEidToLocatorRecord().add(mapping);
+ replyBuilder.getMappingRecordItem().add(new MappingRecordItemBuilder().setMappingRecord(mapping).build());
}
requestHandler.handleMapReply(replyBuilder.build());
}
- private EidToLocatorRecord getNegativeMapping(LispAddressContainer eid, short mask) {
- EidToLocatorRecordBuilder recordBuilder = new EidToLocatorRecordBuilder();
+ private MappingRecord getNegativeMapping(Eid eid) {
+ MappingRecordBuilder recordBuilder = new MappingRecordBuilder();
recordBuilder.setAuthoritative(false);
recordBuilder.setMapVersion((short) 0);
- recordBuilder.setMaskLength(mask);
- recordBuilder.setLispAddressContainer(eid);
+ recordBuilder.setEid(eid);
recordBuilder.setAction(Action.NativelyForward);
if (authenticate && mapService.getAuthenticationKey(eid) != null) {
recordBuilder.setRecordTtl(TTL_RLOC_TIMED_OUT);
return recordBuilder.build();
}
- private void updateSubscribers(LispAddressContainer itrRloc, LispAddressContainer dstEid,
- LispAddressContainer srcEid) {
+ private void updateSubscribers(Rloc itrRloc, Eid dstEid,
+ Eid srcEid) {
SubscriberRLOC subscriberRloc = new SubscriberRLOC(itrRloc, srcEid);
Set<SubscriberRLOC> subscribers = getSubscribers(dstEid);
if (subscribers == null) {
}
// Fixes mapping if request was for simple dst EID but the matched mapping is a SourceDest
- private EidToLocatorRecord fixIfNotSDRequest(EidToLocatorRecord mapping, LispAddressContainer dstEid) {
- if (mapping.getLispAddressContainer().getAddress() instanceof LcafSourceDest
- && !(dstEid.getAddress() instanceof LcafSourceDest)) {
- return new EidToLocatorRecordBuilder(mapping).setLispAddressContainer(
- LcafSourceDestHelper.getDst(mapping.getLispAddressContainer())).build();
+ private MappingRecord fixIfNotSDRequest(MappingRecord mapping, Eid dstEid) {
+ if (mapping.getEid().getAddress() instanceof SourceDestKey
+ && !(dstEid.getAddress() instanceof SourceDestKey)) {
+ return new MappingRecordBuilder(mapping).setEid(
+ SourceDestKeyHelper.getDst(mapping.getEid())).build();
}
return mapping;
}
private boolean locatorsNeedFixing(List<LocatorRecord> locatorRecords) {
for (LocatorRecord record : locatorRecords) {
- if (record.getLispAddressContainer().getAddress() instanceof LcafTrafficEngineering) {
+ if (record.getRloc().getAddress() instanceof ExplicitLocatorPath) {
return true;
}
}
}
// Process locators according to configured policy
- private EidToLocatorRecord updateLocators(EidToLocatorRecord mapping, List<ItrRloc> itrRlocs) {
+ private MappingRecord updateLocators(MappingRecord mapping, List<ItrRloc> itrRlocs) {
// no fixing if elpPolicy is default
if (elpPolicy.equalsIgnoreCase("default")) {
return mapping;
return mapping;
}
- EidToLocatorRecordBuilder recordBuilder = new EidToLocatorRecordBuilder(mapping);
+ MappingRecordBuilder recordBuilder = new MappingRecordBuilder();
recordBuilder.setLocatorRecord(new ArrayList<LocatorRecord>());
try {
for (LocatorRecord record : locatorRecords) {
- LispAddressContainer container = record.getLispAddressContainer();
+ Rloc container = record.getRloc();
// For non-ELP RLOCs, or when ELP policy is default, or itrRlocs is null, just add the locator and be
// done
- if ((!(container.getAddress() instanceof LcafTrafficEngineering))
+ if ((!(container.getAddress() instanceof ExplicitLocatorPath))
|| elpPolicy.equalsIgnoreCase("default") || itrRlocs == null) {
recordBuilder.getLocatorRecord().add(
new LocatorRecordBuilder().setLocalLocator(record.isLocalLocator())
.setRlocProbed(record.isRlocProbed()).setWeight(record.getWeight())
.setPriority(record.getPriority()).setMulticastWeight(record.getMulticastWeight())
.setMulticastPriority(record.getMulticastPriority()).setRouted(record.isRouted())
- .setLispAddressContainer(container).setName(record.getName()).build());
+ .setRloc(container).setLocatorId(record.getLocatorId()).build());
continue;
}
- LcafTrafficEngineeringAddress teAddress = ((LcafTrafficEngineering) container.getAddress())
- .getLcafTrafficEngineeringAddr();
- LispAddressContainer nextHop = getNextELPHop(teAddress, itrRlocs);
+ ExplicitLocatorPath teAddress = ((ExplicitLocatorPath) container.getAddress());
+ SimpleAddress nextHop = getNextELPHop(teAddress, itrRlocs);
if (nextHop != null) {
java.lang.Short priority = record.getPriority();
if (elpPolicy.equalsIgnoreCase("both")) {
.setPriority(record.getPriority())
.setMulticastWeight(record.getMulticastWeight())
.setMulticastPriority(record.getMulticastPriority())
- .setRouted(record.isRouted()).setLispAddressContainer(container)
- .setName(record.getName()).build());
+ .setRouted(record.isRouted()).setRloc(container)
+ .setLocatorId(record.getLocatorId()).build());
// Make the priority of the added simple locator lower so that ELP is used by default if
// the xTR understands ELP. Exclude 255, since that means don't use for unicast forwarding
// XXX Complex cases like several ELPs with different priorities are not handled
.setRlocProbed(record.isRlocProbed()).setWeight(record.getWeight())
.setPriority(priority).setMulticastWeight(record.getMulticastWeight())
.setMulticastPriority(record.getMulticastPriority()).setRouted(record.isRouted())
- .setLispAddressContainer(nextHop).setName(record.getName()).build());
+ .setRloc(LispAddressUtil.toRloc(nextHop)).setLocatorId(record.getLocatorId()).build());
}
}
} catch (ClassCastException cce) {
return recordBuilder.build();
}
- private LispAddressContainer getNextELPHop(LcafTrafficEngineeringAddress elp, List<ItrRloc> itrRlocs) {
- LispAddressContainer nextHop = null;
- List<Hops> hops = elp.getHops();
+ private SimpleAddress getNextELPHop(ExplicitLocatorPath elp, List<ItrRloc> itrRlocs) {
+ SimpleAddress nextHop = null;
+ List<Hop> hops = elp.getExplicitLocatorPath().getHop();
if (hops != null && hops.size() > 0) {
// By default we return the first hop
- nextHop = LispAFIConvertor.toContainer(LispAFIConvertor.toAFIfromPrimitive(hops.get(0).getHop()
- .getPrimitiveAddress()));
- for (Hops hop : hops) {
- LispAddressContainer hopContainer = LispAFIConvertor.toContainer(LispAFIConvertor
- .toAFIfromPrimitive(hop.getHop().getPrimitiveAddress()));
+ nextHop = hops.get(0).getAddress();
+ for (Hop hop : hops) {
+ SimpleAddress hopContainer = hop.getAddress();
for (ItrRloc itrRloc : itrRlocs) {
- if (itrRloc.getLispAddressContainer().equals(hopContainer)) {
+ // XXX Need conversion
+ if (itrRloc.getRloc().equals(hopContainer)) {
int i = hops.indexOf(hop);
if (i < hops.size() - 1) {
- nextHop = LispAFIConvertor.toContainer(LispAFIConvertor.toAFIfromPrimitive(hops.get(i + 1)
- .getHop().getPrimitiveAddress()));
+ nextHop = hops.get(i + 1).getAddress();
return nextHop;
}
}
}
@SuppressWarnings("unchecked")
- private Set<SubscriberRLOC> getSubscribers(LispAddressContainer address) {
+ private Set<SubscriberRLOC> getSubscribers(Eid address) {
return (Set<SubscriberRLOC>) mapService.getData(MappingOrigin.Southbound, address, SubKeys.SUBSCRIBERS);
}
- private void addSubscribers(LispAddressContainer address, Set<SubscriberRLOC> subscribers) {
+ private void addSubscribers(Eid address, Set<SubscriberRLOC> subscribers) {
mapService.addData(MappingOrigin.Southbound, address, SubKeys.SUBSCRIBERS, subscribers);
}
import org.opendaylight.lispflowmapping.interfaces.lisp.IMapNotifyHandler;
import org.opendaylight.lispflowmapping.interfaces.lisp.IMapServerAsync;
import org.opendaylight.lispflowmapping.interfaces.mappingservice.IMappingService;
-import org.opendaylight.lispflowmapping.lisp.util.LcafSourceDestHelper;
-import org.opendaylight.lispflowmapping.lisp.util.LispAFIConvertor;
+import org.opendaylight.lispflowmapping.lisp.util.LispAddressUtil;
import org.opendaylight.lispflowmapping.lisp.util.MapNotifyBuilderHelper;
import org.opendaylight.lispflowmapping.lisp.util.MapRequestUtil;
-import org.opendaylight.lispflowmapping.lisp.util.MaskUtil;
+import org.opendaylight.lispflowmapping.lisp.util.SourceDestKeyHelper;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.lisp.address.types.rev151105.lisp.address.address.SourceDestKey;
import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.MapRegister;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.eidrecords.EidRecord;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.eidrecords.EidRecordBuilder;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.eidtolocatorrecords.EidToLocatorRecord;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.eidtolocatorrecords.EidToLocatorRecordBuilder;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.lispaddress.LispAddressContainer;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.lispaddress.lispaddresscontainer.address.LcafSourceDest;
+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.eid.list.EidItem;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.eid.list.EidItemBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.mapnotifymessage.MapNotifyBuilder;
+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;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.mapping.record.list.MappingRecordItem;
import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.maprequestnotification.MapRequestBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.mappingservice.rev150906.MappingChange;
import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.mappingservice.rev150906.MappingChanged;
import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.mappingservice.rev150906.MappingOrigin;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.mappingservice.rev150906.MappingserviceListener;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.mappingservice.rev150906.OdlMappingserviceListener;
import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.mappingservice.rev150906.SiteId;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.mappingservice.rev150906.mapping.authkey.container.MappingAuthkey;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import com.google.common.base.Preconditions;
-public class MapServer implements IMapServerAsync, MappingserviceListener {
+public class MapServer implements IMapServerAsync, OdlMappingserviceListener {
protected static final Logger LOG = LoggerFactory.getLogger(MapServer.class);
private IMappingService mapService;
public void handleMapRegister(MapRegister mapRegister) {
boolean failed = false;
String password = null;
- for (EidToLocatorRecord record : mapRegister.getEidToLocatorRecord()) {
+ for (MappingRecordItem record : mapRegister.getMappingRecordItem()) {
+ MappingRecord mapping = record.getMappingRecord();
if (authenticate) {
- password = mapService.getAuthenticationKey(record.getLispAddressContainer());
+ MappingAuthkey authkey = mapService.getAuthenticationKey(mapping.getEid());
+ if (authkey != null) {
+ password = authkey.getKeyString();
+ }
if (!LispAuthenticationUtil.validate(mapRegister, password)) {
LOG.warn("Authentication failed");
failed = true;
break;
}
}
- EidToLocatorRecord oldMapping = (EidToLocatorRecord) mapService.getMapping(MappingOrigin.Southbound,
- record.getLispAddressContainer());
- mapService.addMapping(MappingOrigin.Southbound, record.getLispAddressContainer(), getSiteId(mapRegister),
- record);
- if (subscriptionService && !record.equals(oldMapping)) {
- LOG.debug("Sending SMRs for subscribers of {}", record.getLispAddressContainer());
- Set<SubscriberRLOC> subscribers = getSubscribers(record.getLispAddressContainer());
- sendSmrs(record, subscribers);
+ MappingRecord oldMapping = (MappingRecord) mapService.getMapping(MappingOrigin.Southbound,
+ mapping.getEid());
+ mapService.addMapping(MappingOrigin.Southbound, mapping.getEid(), getSiteId(mapRegister), mapping);
+ if (subscriptionService && !mapping.equals(oldMapping)) {
+ LOG.debug("Sending SMRs for subscribers of {}", mapping.getEid());
+ Set<SubscriberRLOC> subscribers = getSubscribers(mapping.getEid());
+ sendSmrs(mapping, subscribers);
}
}
if (!failed) {
@Override
public void onMappingChanged(MappingChanged notification) {
if (subscriptionService) {
- sendSmrs(new EidToLocatorRecordBuilder(notification.getMapping()).build(), getSubscribers(notification
- .getMapping().getLispAddressContainer()));
- if (notification.getChange().equals(MappingChange.Removed)) {
- removeSubscribers(notification.getMapping().getLispAddressContainer());
+ sendSmrs(notification.getMappingRecord(), getSubscribers(notification.getMappingRecord().getEid()));
+ if (notification.getChangeType().equals(MappingChange.Removed)) {
+ removeSubscribers(notification.getMappingRecord().getEid());
}
}
}
- private void sendSmrs(EidToLocatorRecord record, Set<SubscriberRLOC> subscribers) {
- LispAddressContainer eid = record.getLispAddressContainer();
+ private void sendSmrs(MappingRecord record, Set<SubscriberRLOC> subscribers) {
+ Eid eid = record.getEid();
handleSmr(record, subscribers, notifyHandler);
// For SrcDst LCAF also send SMRs to Dst prefix
- if (eid.getAddress() instanceof LcafSourceDest) {
- LispAddressContainer dstAddr = LispAFIConvertor.toContainer(LcafSourceDestHelper.getDstAfi(eid));
- short dstMask = LcafSourceDestHelper.getDstMask(eid);
+ if (eid.getAddress() instanceof SourceDestKey) {
+ Eid dstAddr = SourceDestKeyHelper.getDst(eid);
subscribers = getSubscribers(dstAddr);
- EidToLocatorRecord newRecord = new EidToLocatorRecordBuilder().setAction(record.getAction())
+ MappingRecord newRecord = new MappingRecordBuilder().setAction(record.getAction())
.setAuthoritative(record.isAuthoritative()).setLocatorRecord(record.getLocatorRecord())
.setMapVersion(record.getMapVersion()).setRecordTtl(record.getRecordTtl())
- .setLispAddressContainer(dstAddr).setMaskLength(dstMask).build();
+ .setEid(dstAddr).build();
handleSmr(newRecord, subscribers, notifyHandler);
}
}
- private void handleSmr(EidToLocatorRecord record, Set<SubscriberRLOC> subscribers, IMapNotifyHandler callback) {
+ private void handleSmr(MappingRecord record, Set<SubscriberRLOC> subscribers, IMapNotifyHandler callback) {
if (subscribers == null) {
return;
}
- MapRequestBuilder mrb = MapRequestUtil.prepareSMR(record.getLispAddressContainer(),
- LispAFIConvertor.toContainer(getLocalAddress()));
+ MapRequestBuilder mrb = MapRequestUtil.prepareSMR(record.getEid(), LispAddressUtil.toRloc(getLocalAddress()));
LOG.trace("Built SMR packet: " + mrb.build().toString());
for (SubscriberRLOC subscriber : subscribers) {
if (subscriber.timedOut()) {
try {
// The address stored in the SMR's EID record is used as Source EID in the SMR-invoked Map-Request.
// To ensure consistent behavior it is set to the value used to originally request a given mapping
- mrb.setEidRecord(new ArrayList<EidRecord>());
- mrb.getEidRecord()
- .add(new EidRecordBuilder()
- .setMask(
- (short) MaskUtil.getMaxMask(LispAFIConvertor.toAFI(subscriber.getSrcEid())))
- .setLispAddressContainer(subscriber.getSrcEid()).build());
+ mrb.setEidItem(new ArrayList<EidItem>());
+ mrb.getEidItem().add(new EidItemBuilder().setEid(subscriber.getSrcEid()).build());
callback.handleSMR(mrb.build(), subscriber.getSrcRloc());
} catch (Exception e) {
LOG.error("Errors encountered while handling SMR:" + ExceptionUtils.getStackTrace(e));
}
}
}
- addSubscribers(record.getLispAddressContainer(), subscribers);
+ addSubscribers(record.getEid(), subscribers);
}
@SuppressWarnings("unchecked")
- private Set<SubscriberRLOC> getSubscribers(LispAddressContainer address) {
+ private Set<SubscriberRLOC> getSubscribers(Eid address) {
return (Set<SubscriberRLOC>) mapService.getData(MappingOrigin.Southbound, address, SubKeys.SUBSCRIBERS);
}
- private void removeSubscribers(LispAddressContainer address) {
+ private void removeSubscribers(Eid address) {
mapService.removeData(MappingOrigin.Southbound, address, SubKeys.SUBSCRIBERS);
}
- private void addSubscribers(LispAddressContainer address, Set<SubscriberRLOC> subscribers) {
+ private void addSubscribers(Eid address, Set<SubscriberRLOC> subscribers) {
mapService.addData(MappingOrigin.Southbound, address, SubKeys.SUBSCRIBERS, subscribers);
}
import org.opendaylight.lispflowmapping.interfaces.dao.MappingEntry;
import org.opendaylight.lispflowmapping.interfaces.dao.SubKeys;
import org.opendaylight.lispflowmapping.interfaces.mapcache.IMapCache;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.lispaddress.LispAddressContainer;
+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.mapping.authkey.container.MappingAuthkey;
/**
* Flat key implementation of a map-cache. As the name suggests, no longest prefix matching is done for IP addresses
}
@Override
- public void addMapping(LispAddressContainer key, Object data, boolean shouldOverwrite) {
+ public void addMapping(Eid key, Object data, boolean shouldOverwrite) {
dao.put(key, new MappingEntry<>(SubKeys.REGDATE, new Date(System.currentTimeMillis())));
dao.put(key, new MappingEntry<>(SubKeys.RECORD, data));
}
@Override
- public Object getMapping(LispAddressContainer srcKey, LispAddressContainer dstKey) {
+ public Object getMapping(Eid srcKey, Eid dstKey) {
if (dstKey == null) {
return null;
}
}
@Override
- public void removeMapping(LispAddressContainer key, boolean overwrite) {
+ public void removeMapping(Eid key, boolean overwrite) {
dao.removeSpecific(key, SubKeys.RECORD);
}
@Override
- public void addAuthenticationKey(LispAddressContainer key, String authKey) {
+ public void addAuthenticationKey(Eid key, MappingAuthkey authKey) {
dao.put(key, new MappingEntry<>(SubKeys.AUTH_KEY, authKey));
}
@Override
- public String getAuthenticationKey(LispAddressContainer key) {
+ public MappingAuthkey getAuthenticationKey(Eid key) {
Object data = dao.getSpecific(key, SubKeys.AUTH_KEY);
- if (data instanceof String) {
- return (String) data;
+ if (data instanceof MappingAuthkey) {
+ return (MappingAuthkey) data;
} else {
return null;
}
}
@Override
- public void removeAuthenticationKey(LispAddressContainer key) {
+ public void removeAuthenticationKey(Eid key) {
dao.removeSpecific(key, SubKeys.AUTH_KEY);
}
@Override
- public void updateMappingRegistration(LispAddressContainer key) {
+ public void updateMappingRegistration(Eid key) {
if (dao.get(key) != null) {
dao.put(key, new MappingEntry<>(SubKeys.REGDATE, new Date(System.currentTimeMillis())));
}
}
@Override
- public void addData(LispAddressContainer key, String subKey, Object data) {
+ public void addData(Eid key, String subKey, Object data) {
dao.put(key, new MappingEntry<>(subKey, data));
}
@Override
- public Object getData(LispAddressContainer key, String subKey) {
+ public Object getData(Eid key, String subKey) {
return dao.getSpecific(key, subKey);
}
@Override
- public void removeData(LispAddressContainer key, String subKey) {
+ public void removeData(Eid key, String subKey) {
dao.removeSpecific(key, subKey);
}
import org.opendaylight.lispflowmapping.interfaces.dao.MappingEntry;
import org.opendaylight.lispflowmapping.interfaces.dao.SubKeys;
import org.opendaylight.lispflowmapping.interfaces.mapcache.IMapCache;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.lispaddress.LispAddressContainer;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.lispaddress.lispaddresscontainer.address.LcafSourceDest;
-import org.opendaylight.lispflowmapping.lisp.util.LcafSourceDestHelper;
-import org.opendaylight.lispflowmapping.lisp.util.LispAFIConvertor;
import org.opendaylight.lispflowmapping.lisp.util.MaskUtil;
+import org.opendaylight.lispflowmapping.lisp.util.SourceDestKeyHelper;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.lisp.address.types.rev151105.lisp.address.address.SourceDestKey;
+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.mapping.authkey.container.MappingAuthkey;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
this.dao = dao;
}
- public void addMapping(LispAddressContainer key, Object value, boolean shouldOverwrite) {
- LispAddressContainer eid = MaskUtil.normalize(key);
- if (eid.getAddress() instanceof LcafSourceDest) {
- LispAddressContainer srcKey = LcafSourceDestHelper.getSrc(eid);
+ public void addMapping(Eid key, Object value, boolean shouldOverwrite) {
+ Eid eid = MaskUtil.normalize(key);
+ if (eid.getAddress() instanceof SourceDestKey) {
+ Eid srcKey = SourceDestKeyHelper.getSrc(eid);
ILispDAO srcDstDao = getOrInstantiateSDInnerDao(eid, dao);
srcDstDao.put(srcKey, new MappingEntry<>(SubKeys.REGDATE, new Date(System.currentTimeMillis())));
srcDstDao.put(srcKey, new MappingEntry<>(SubKeys.RECORD, value));
// Method returns the DAO entry (hash) corresponding to either the longest prefix match of eid, if eid is maskable,
// or the exact match otherwise. eid must be a 'simple' address
- private Map<String, ?> getDaoEntryBest(LispAddressContainer eid, ILispDAO dao) {
- if (MaskUtil.isMaskable(eid)) {
- LispAddressContainer key;
- short mask = MaskUtil.getMaskForAddress(eid);
+ private Map<String, ?> getDaoEntryBest(Eid eid, ILispDAO dao) {
+ if (MaskUtil.isMaskable(eid.getAddress())) {
+ Eid key;
+ short mask = MaskUtil.getMaskForAddress(eid.getAddress());
while (mask > 0) {
key = MaskUtil.normalize(eid, mask);
mask--;
}
}
- private Object getMappingExactSD(LispAddressContainer srcEid, LispAddressContainer dstEid,
- ILispDAO dao) {
+ private Object getMappingExactSD(Eid srcEid, Eid dstEid, ILispDAO dao) {
Map<String, ?> daoEntry = dao.get(dstEid);
if (daoEntry != null) {
// try SrcDst eid lookup
}
// Returns the mapping corresponding to the longest prefix match for eid. eid must be a simple (maskable or not) address
- private Object getMappingLpmEid(LispAddressContainer eid, ILispDAO dao) {
+ private Object getMappingLpmEid(Eid eid, ILispDAO dao) {
if (eid == null) {
return null;
}
// Returns a mapping corresponding to either the longest prefix match for both dstEid and srcEid,
// if a SourceDest mapping exists, or to dstEid
- private Object getMappingLpmSD(LispAddressContainer srcEid, LispAddressContainer dstEid, ILispDAO dao) {
+ private Object getMappingLpmSD(Eid srcEid, Eid dstEid, ILispDAO dao) {
Map<String, ?> daoEntry = getDaoEntryBest(dstEid, dao);
if (daoEntry != null) {
// try SrcDst eid lookup
return null;
}
- public Object getMapping(LispAddressContainer srcEid, LispAddressContainer dstEid) {
+ public Object getMapping(Eid srcEid, Eid dstEid) {
if (dstEid == null) {
return null;
}
// a map-request for an actual SrcDst LCAF, ignore src eid
- if (dstEid.getAddress() instanceof LcafSourceDest) {
- LispAddressContainer srcAddr = LcafSourceDestHelper.getSrc(dstEid);
- LispAddressContainer dstAddr = LcafSourceDestHelper.getDst(dstEid);
+ if (dstEid.getAddress() instanceof SourceDestKey) {
+ Eid srcAddr = SourceDestKeyHelper.getSrc(dstEid);
+ Eid dstAddr = SourceDestKeyHelper.getDst(dstEid);
return getMappingLpmSD(srcAddr, dstAddr, dao);
}
return getMappingLpmSD(srcEid, dstEid, dao);
}
- public void removeMapping(LispAddressContainer eid, boolean overwrite) {
+ public void removeMapping(Eid eid, boolean overwrite) {
eid = MaskUtil.normalize(eid);
- if (eid.getAddress() instanceof LcafSourceDest) {
+ if (eid.getAddress() instanceof SourceDestKey) {
ILispDAO db = getSDInnerDao(eid, dao);
if (db != null) {
- db.removeSpecific(LcafSourceDestHelper.getSrc(eid),
+ db.removeSpecific(SourceDestKeyHelper.getSrc(eid),
SubKeys.RECORD);
}
} else {
}
}
- public void addAuthenticationKey(LispAddressContainer eid, String key) {
+ public void addAuthenticationKey(Eid eid, MappingAuthkey key) {
eid = MaskUtil.normalize(eid);
- if (eid.getAddress() instanceof LcafSourceDest) {
+ if (eid.getAddress() instanceof SourceDestKey) {
ILispDAO srcDstDao = getOrInstantiateSDInnerDao(eid, dao);
- srcDstDao.put(LcafSourceDestHelper.getSrc(eid), new MappingEntry<String>(SubKeys.AUTH_KEY, key));
+ srcDstDao.put(SourceDestKeyHelper.getSrc(eid), new MappingEntry<>(SubKeys.AUTH_KEY, key));
} else {
- dao.put(eid, new MappingEntry<String>(SubKeys.AUTH_KEY, key));
+ dao.put(eid, new MappingEntry<>(SubKeys.AUTH_KEY, key));
}
}
- private String getAuthKeyLpm(LispAddressContainer prefix, ILispDAO db) {
- short maskLength = MaskUtil.getMaskForAddress(prefix);
+ private MappingAuthkey getAuthKeyLpm(Eid prefix, ILispDAO db) {
+ short maskLength = MaskUtil.getMaskForAddress(prefix.getAddress());
while (maskLength >= 0) {
- LispAddressContainer key = MaskUtil.normalize(prefix, maskLength);
+ Eid key = MaskUtil.normalize(prefix, maskLength);
Object password = db.getSpecific(key, SubKeys.AUTH_KEY);
- if (password != null && password instanceof String) {
- return (String) password;
+ if (password != null && password instanceof MappingAuthkey) {
+ return (MappingAuthkey) password;
}
maskLength -= 1;
}
return null;
}
- public String getAuthenticationKey(LispAddressContainer eid) {
- if (MaskUtil.isMaskable(LispAFIConvertor.toAFI(eid))) {
+ public MappingAuthkey getAuthenticationKey(Eid eid) {
+ if (MaskUtil.isMaskable(eid.getAddress())) {
return getAuthKeyLpm(eid, dao);
- } else if (eid.getAddress() instanceof LcafSourceDest) {
+ } else if (eid.getAddress() instanceof SourceDestKey) {
// NOTE: this is an exact match, not a longest prefix match
ILispDAO srcDstDao = getSDInnerDao(eid, dao);
if (srcDstDao != null) {
- return getAuthKeyLpm(LcafSourceDestHelper.getSrc(eid), srcDstDao);
+ return getAuthKeyLpm(SourceDestKeyHelper.getSrc(eid), srcDstDao);
}
return null;
} else {
Object password = dao.getSpecific(eid, SubKeys.AUTH_KEY);
- if (password != null && password instanceof String) {
- return (String) password;
+ if (password != null && password instanceof MappingAuthkey) {
+ return (MappingAuthkey) password;
} else {
LOG.warn("Failed to find password!");
return null;
}
}
- public void removeAuthenticationKey(LispAddressContainer eid) {
+ public void removeAuthenticationKey(Eid eid) {
eid = MaskUtil.normalize(eid);
- if (eid.getAddress() instanceof LcafSourceDest) {
+ if (eid.getAddress() instanceof SourceDestKey) {
ILispDAO srcDstDao = getSDInnerDao(eid, dao);
if (srcDstDao != null) {
srcDstDao.removeSpecific(eid, SubKeys.AUTH_KEY);
// SrcDst LCAFs are stored in a 2-tier DAO with dst having priority over src.
// This method returns the DAO associated to a dst or creates it if it doesn't exist.
- private ILispDAO getOrInstantiateSDInnerDao(LispAddressContainer address, ILispDAO dao) {
- LispAddressContainer dstKey = LcafSourceDestHelper.getDst(address);
+ private ILispDAO getOrInstantiateSDInnerDao(Eid address, ILispDAO dao) {
+ Eid dstKey = SourceDestKeyHelper.getDst(address);
ILispDAO srcDstDao = (ILispDAO) dao.getSpecific(dstKey, SubKeys.LCAF_SRCDST);
if (srcDstDao == null) {
// inserts nested table for source
// SrcDst LCAFs are stored in a 2-tier DAO with dst having priority over src.
// This method returns the DAO associated to dst or null if it doesn't exist.
- private ILispDAO getSDInnerDao(LispAddressContainer address, ILispDAO dao) {
- return (ILispDAO) dao.getSpecific(LcafSourceDestHelper.getDst(address), SubKeys.LCAF_SRCDST);
+ private ILispDAO getSDInnerDao(Eid address, ILispDAO dao) {
+ return (ILispDAO) dao.getSpecific(SourceDestKeyHelper.getDst(address), SubKeys.LCAF_SRCDST);
}
public String printMappings() {
}
@Override
- public void updateMappingRegistration(LispAddressContainer key) {
+ public void updateMappingRegistration(Eid key) {
}
@Override
- public void addData(LispAddressContainer key, String subKey, Object data) {
+ public void addData(Eid key, String subKey, Object data) {
key = MaskUtil.normalize(key);
- if (key.getAddress() instanceof LcafSourceDest) {
+ if (key.getAddress() instanceof SourceDestKey) {
ILispDAO srcDstDao = getOrInstantiateSDInnerDao(key, dao);
- srcDstDao.put(LcafSourceDestHelper.getSrc(key), new MappingEntry<Object>(subKey, data));
+ srcDstDao.put(SourceDestKeyHelper.getSrc(key), new MappingEntry<Object>(subKey, data));
} else {
dao.put(key, new MappingEntry<Object>(subKey, data));
}
}
@Override
- public Object getData(LispAddressContainer eid, String subKey) {
- if (eid.getAddress() instanceof LcafSourceDest) {
+ public Object getData(Eid eid, String subKey) {
+ if (eid.getAddress() instanceof SourceDestKey) {
ILispDAO srcDstDao = getSDInnerDao(eid, dao);
- return srcDstDao.getSpecific(LcafSourceDestHelper.getSrc(eid), subKey);
+ return srcDstDao.getSpecific(SourceDestKeyHelper.getSrc(eid), subKey);
} else {
return dao.getSpecific(eid, subKey);
}
}
@Override
- public void removeData(LispAddressContainer key, String subKey) {
+ public void removeData(Eid key, String subKey) {
key = MaskUtil.normalize(key);
- if (key.getAddress() instanceof LcafSourceDest) {
+ if (key.getAddress() instanceof SourceDestKey) {
ILispDAO db = getSDInnerDao(key, dao);
if (db != null) {
- db.removeSpecific(LcafSourceDestHelper.getSrc(key), subKey);
+ db.removeSpecific(SourceDestKeyHelper.getSrc(key), subKey);
}
} else {
dao.removeSpecific(key, subKey);
import org.opendaylight.lispflowmapping.interfaces.dao.MappingEntry;
import org.opendaylight.lispflowmapping.interfaces.dao.SubKeys;
import org.opendaylight.lispflowmapping.interfaces.mapcache.IMapCache;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.lispaddress.LispAddressContainer;
-import org.opendaylight.lispflowmapping.lisp.util.LispAFIConvertor;
import org.opendaylight.lispflowmapping.lisp.util.MaskUtil;
+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.mapping.authkey.container.MappingAuthkey;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
this.dao = dao;
}
- public void addMapping(LispAddressContainer key, Object value, boolean shouldOverwrite) {
- LispAddressContainer eid = MaskUtil.normalize(key);
+ public void addMapping(Eid key, Object value, boolean shouldOverwrite) {
+ Eid eid = MaskUtil.normalize(key);
dao.put(eid, new MappingEntry<>(SubKeys.REGDATE, new Date(System.currentTimeMillis())));
dao.put(eid, new MappingEntry<>(SubKeys.RECORD, value));
}
// Method returns the DAO entry (hash) corresponding to either the longest prefix match of eid, if eid is maskable,
// or the exact match otherwise. eid must be a 'simple' address
- private Map<String, ?> getDaoEntryBest(LispAddressContainer key, ILispDAO dao) {
- if (MaskUtil.isMaskable(key)) {
- LispAddressContainer lookupKey;
- short mask = MaskUtil.getMaskForAddress(key);
+ private Map<String, ?> getDaoEntryBest(Eid key, ILispDAO dao) {
+ if (MaskUtil.isMaskable(key.getAddress())) {
+ Eid lookupKey;
+ short mask = MaskUtil.getMaskForAddress(key.getAddress());
while (mask > 0) {
lookupKey = MaskUtil.normalize(key, mask);
mask--;
// Method returns the DAO entry (hash) corresponding to either the longest prefix match of eid, if eid is maskable,
// or the exact match otherwise. eid must be a 'simple' address
- private SimpleImmutableEntry<LispAddressContainer, Map<String, ?>> getDaoPairEntryBest(LispAddressContainer key, ILispDAO dao) {
- if (MaskUtil.isMaskable(key)) {
- LispAddressContainer lookupKey;
- short mask = MaskUtil.getMaskForAddress(key);
+ private SimpleImmutableEntry<Eid, Map<String, ?>> getDaoPairEntryBest(Eid key, ILispDAO dao) {
+ if (MaskUtil.isMaskable(key.getAddress())) {
+ Eid lookupKey;
+ short mask = MaskUtil.getMaskForAddress(key.getAddress());
while (mask > 0) {
lookupKey = MaskUtil.normalize(key, mask);
mask--;
Map<String, ?> entry = dao.get(lookupKey);
if (entry != null) {
- return new SimpleImmutableEntry<LispAddressContainer, Map<String, ?>>(lookupKey, entry);
+ return new SimpleImmutableEntry<Eid, Map<String, ?>>(lookupKey, entry);
}
}
return null;
} else {
Map<String, ?> entry = dao.get(key);
if (entry != null) {
- return new SimpleImmutableEntry<LispAddressContainer, Map<String, ?>>(key, entry);
+ return new SimpleImmutableEntry<Eid, Map<String, ?>>(key, entry);
} else {
return null;
}
// Returns the mapping corresponding to the longest prefix match for eid. eid must be a simple (maskable or not)
// address
- private Object getMappingLpmEid(LispAddressContainer eid, ILispDAO dao) {
+ private Object getMappingLpmEid(Eid eid, ILispDAO dao) {
Map<String, ?> daoEntry = getDaoEntryBest(eid, dao);
if (daoEntry != null) {
return daoEntry.get(SubKeys.RECORD);
// Returns the matched key and mapping corresponding to the longest prefix match for eid. eid must be a simple
// (maskable or not) address
- private SimpleImmutableEntry<LispAddressContainer, Object> getMappingPairLpmEid(LispAddressContainer eid, ILispDAO dao) {
- SimpleImmutableEntry<LispAddressContainer, Map<String, ?>> daoEntry = getDaoPairEntryBest(eid, dao);
+ private SimpleImmutableEntry<Eid, Object> getMappingPairLpmEid(Eid eid, ILispDAO dao) {
+ SimpleImmutableEntry<Eid, Map<String, ?>> daoEntry = getDaoPairEntryBest(eid, dao);
if (daoEntry != null) {
- return new SimpleImmutableEntry<LispAddressContainer, Object>(daoEntry.getKey(), daoEntry.getValue().get(
+ return new SimpleImmutableEntry<Eid, Object>(daoEntry.getKey(), daoEntry.getValue().get(
SubKeys.RECORD));
} else {
return null;
}
}
- public Object getMapping(LispAddressContainer srcEid, LispAddressContainer dstEid) {
+ public Object getMapping(Eid srcEid, Eid dstEid) {
if (dstEid == null) {
return null;
}
return getMappingLpmEid(dstEid, dao);
}
- public void removeMapping(LispAddressContainer eid, boolean overwrite) {
+ public void removeMapping(Eid eid, boolean overwrite) {
eid = MaskUtil.normalize(eid);
dao.removeSpecific(eid, SubKeys.RECORD);
}
- public void addAuthenticationKey(LispAddressContainer eid, String key) {
+ public void addAuthenticationKey(Eid eid, MappingAuthkey key) {
eid = MaskUtil.normalize(eid);
- dao.put(eid, new MappingEntry<String>(SubKeys.AUTH_KEY, key));
+ dao.put(eid, new MappingEntry<>(SubKeys.AUTH_KEY, key));
}
- private String getAuthKeyLpm(LispAddressContainer prefix, ILispDAO db) {
- short maskLength = MaskUtil.getMaskForAddress(prefix);
+ private MappingAuthkey getAuthKeyLpm(Eid prefix, ILispDAO db) {
+ short maskLength = MaskUtil.getMaskForAddress(prefix.getAddress());
while (maskLength >= 0) {
- LispAddressContainer key = MaskUtil.normalize(prefix, maskLength);
+ Eid key = MaskUtil.normalize(prefix, maskLength);
Object password = db.getSpecific(key, SubKeys.AUTH_KEY);
- if (password != null && password instanceof String) {
- return (String) password;
+ if (password != null && password instanceof MappingAuthkey) {
+ return (MappingAuthkey) password;
}
maskLength -= 1;
}
return null;
}
- public String getAuthenticationKey(LispAddressContainer eid) {
- if (MaskUtil.isMaskable(LispAFIConvertor.toAFI(eid))) {
+ public MappingAuthkey getAuthenticationKey(Eid eid) {
+ if (MaskUtil.isMaskable(eid.getAddress())) {
return getAuthKeyLpm(eid, dao);
} else {
Object password = dao.getSpecific(eid, SubKeys.AUTH_KEY);
- if (password != null && password instanceof String) {
- return (String) password;
+ if (password != null && password instanceof MappingAuthkey) {
+ return (MappingAuthkey) password;
} else {
LOG.warn("Failed to find password!");
return null;
}
}
- public void removeAuthenticationKey(LispAddressContainer eid) {
+ public void removeAuthenticationKey(Eid eid) {
eid = MaskUtil.normalize(eid);
dao.removeSpecific(eid, SubKeys.AUTH_KEY);
}
}
@Override
- public void updateMappingRegistration(LispAddressContainer key) {
+ public void updateMappingRegistration(Eid key) {
Map<String, ?> daoEntry = getDaoEntryBest(key, dao);
if (daoEntry != null) {
dao.put(key, new MappingEntry<>(SubKeys.REGDATE, new Date(System.currentTimeMillis())));
}
@Override
- public void addData(LispAddressContainer key, String subKey, Object data) {
- LispAddressContainer normKey = MaskUtil.normalize(key);
+ public void addData(Eid key, String subKey, Object data) {
+ Eid normKey = MaskUtil.normalize(key);
dao.put(normKey, new MappingEntry<>(subKey, data));
}
@Override
- public Object getData(LispAddressContainer key, String subKey) {
+ public Object getData(Eid key, String subKey) {
return dao.getSpecific(key, subKey);
}
@Override
- public void removeData(LispAddressContainer key, String subKey) {
+ public void removeData(Eid key, String subKey) {
dao.removeSpecific(key, subKey);
}
}
import org.opendaylight.lispflowmapping.interfaces.mapcache.IMappingSystem;
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.mapping.database.InstanceId;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.mappingservice.rev150906.mapping.database.VirtualNetworkIdentifier;
import org.opendaylight.yangtools.yang.binding.DataObject;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
import org.slf4j.Logger;
public AuthenticationKeyDataListener(DataBroker broker, IMappingSystem mapSystem) {
setBroker(broker);
setMappingSystem(mapSystem);
- setPath(InstanceIdentifier.create(MappingDatabase.class).child(InstanceId.class)
+ setPath(InstanceIdentifier.create(MappingDatabase.class).child(VirtualNetworkIdentifier.class)
.child(AuthenticationKey.class));
LOG.trace("Registering AuthenticationKey listener.");
registerDataChangeListener();
LOG.trace("Key: {}", entry.getKey());
LOG.trace("Value: {}", authkey);
- mapSystem.addAuthenticationKey(authkey.getLispAddressContainer(), authkey.getAuthkey());
+ mapSystem.addAuthenticationKey(authkey.getEid(), authkey.getMappingAuthkey());
}
}
LOG.trace("Key: {}", entry.getKey());
LOG.trace("Value: {}", authkey);
- mapSystem.addAuthenticationKey(authkey.getLispAddressContainer(), authkey.getAuthkey());
+ mapSystem.addAuthenticationKey(authkey.getEid(), authkey.getMappingAuthkey());
}
}
LOG.trace("Key: {}", entry);
LOG.trace("Value: {}", authkey);
- mapSystem.removeAuthenticationKey(authkey.getLispAddressContainer());
+ mapSystem.removeAuthenticationKey(authkey.getEid());
}
}
}
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.Mapping;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.mappingservice.rev150906.mapping.database.InstanceId;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.mappingservice.rev150906.mapping.database.VirtualNetworkIdentifier;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
}
public void addAuthenticationKey(AuthenticationKey authenticationKey) {
- LOG.debug("MD-SAL: Adding authentication key '{}' for {}", authenticationKey.getAuthkey(),
- LispAddressStringifier.getString(authenticationKey.getLispAddressContainer()));
+ LOG.debug("MD-SAL: Adding authentication key '{}' for {}", authenticationKey.getMappingAuthkey().getKeyString(),
+ LispAddressStringifier.getString(authenticationKey.getEid()));
InstanceIdentifier<AuthenticationKey> path = InstanceIdentifierUtil
- .createAuthenticationKeyIid(authenticationKey.getLispAddressContainer());
+ .createAuthenticationKeyIid(authenticationKey.getEid());
writePutTransaction(path, authenticationKey, LogicalDatastoreType.CONFIGURATION,
"Adding authentication key to config datastrore failed");
}
public void addMapping(Mapping mapping) {
LOG.debug("MD-SAL: Adding mapping for {}",
- LispAddressStringifier.getString(mapping.getLispAddressContainer()));
+ LispAddressStringifier.getString(mapping.getMappingRecord().getEid()));
InstanceIdentifier<Mapping> path = InstanceIdentifierUtil
- .createMappingIid(mapping.getLispAddressContainer(), mapping.getOrigin());
+ .createMappingIid(mapping.getMappingRecord().getEid(), mapping.getOrigin());
writePutTransaction(path, mapping, LogicalDatastoreType.CONFIGURATION,
"Adding mapping to config datastrore failed");
}
public void removeAuthenticationKey(AuthenticationKey authenticationKey) {
LOG.debug("MD-SAL: Removing authentication key for {}",
- LispAddressStringifier.getString(authenticationKey.getLispAddressContainer()));
+ LispAddressStringifier.getString(authenticationKey.getEid()));
InstanceIdentifier<AuthenticationKey> path = InstanceIdentifierUtil
- .createAuthenticationKeyIid(authenticationKey.getLispAddressContainer());
+ .createAuthenticationKeyIid(authenticationKey.getEid());
deleteTransaction(path, LogicalDatastoreType.CONFIGURATION,
"Deleting authentication key from config datastrore failed");
}
public void removeMapping(Mapping mapping) {
LOG.debug("MD-SAL: Removing mapping for {}",
- LispAddressStringifier.getString(mapping.getLispAddressContainer()));
+ LispAddressStringifier.getString(mapping.getMappingRecord().getEid()));
InstanceIdentifier<Mapping> path = InstanceIdentifierUtil
- .createMappingIid(mapping.getLispAddressContainer(), mapping.getOrigin());
+ .createMappingIid(mapping.getMappingRecord().getEid(), mapping.getOrigin());
deleteTransaction(path, LogicalDatastoreType.CONFIGURATION, "Deleting mapping from config datastrore failed");
}
public void updateAuthenticationKey(AuthenticationKey authenticationKey) {
LOG.debug("MD-SAL: Updating authentication key for {} with '{}'",
- LispAddressStringifier.getString(authenticationKey.getLispAddressContainer()),
- authenticationKey.getAuthkey());
+ LispAddressStringifier.getString(authenticationKey.getEid()),
+ authenticationKey.getMappingAuthkey().getKeyString());
InstanceIdentifier<AuthenticationKey> path = InstanceIdentifierUtil
- .createAuthenticationKeyIid(authenticationKey.getLispAddressContainer());
+ .createAuthenticationKeyIid(authenticationKey.getEid());
writePutTransaction(path, authenticationKey, LogicalDatastoreType.CONFIGURATION,
"Updating authentication key in config datastrore failed");
}
public void updateMapping(Mapping mapping) {
LOG.debug("MD-SAL: Updating mapping for {}",
- LispAddressStringifier.getString(mapping.getLispAddressContainer()));
+ LispAddressStringifier.getString(mapping.getMappingRecord().getEid()));
InstanceIdentifier<Mapping> path = InstanceIdentifierUtil
- .createMappingIid(mapping.getLispAddressContainer(), mapping.getOrigin());
+ .createMappingIid(mapping.getMappingRecord().getEid(), mapping.getOrigin());
writePutTransaction(path, mapping, LogicalDatastoreType.CONFIGURATION,
"Updating mapping in config datastrore failed");
}
MappingDatabase mdb = readTransaction(path, LogicalDatastoreType.CONFIGURATION);
if (mdb != null) {
- for (InstanceId id : mdb.getInstanceId()) {
+ for (VirtualNetworkIdentifier id : mdb.getVirtualNetworkIdentifier()) {
List<Mapping> ms = id.getMapping();
if (ms != null) {
mappings.addAll(ms);
MappingDatabase mdb = readTransaction(path, LogicalDatastoreType.CONFIGURATION);
if (mdb != null) {
- for (InstanceId id : mdb.getInstanceId()) {
+ for (VirtualNetworkIdentifier id : mdb.getVirtualNetworkIdentifier()) {
List<AuthenticationKey> keys = id.getAuthenticationKey();
if (keys != null) {
authKeys.addAll(keys);
import org.opendaylight.controller.md.sal.common.api.data.AsyncDataChangeEvent;
import org.opendaylight.lispflowmapping.implementation.util.MSNotificationInputUtil;
import org.opendaylight.lispflowmapping.interfaces.mapcache.IMappingSystem;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.eidtolocatorrecords.EidToLocatorRecordBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.mappingservice.rev150906.MappingChange;
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.Mapping;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.mappingservice.rev150906.mapping.database.InstanceId;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.mappingservice.rev150906.mapping.database.VirtualNetworkIdentifier;
import org.opendaylight.yangtools.yang.binding.DataObject;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
import org.slf4j.Logger;
setBroker(broker);
setMappingSystem(msmr);
setNotificationProviderService(nps);
- setPath(InstanceIdentifier.create(MappingDatabase.class).child(InstanceId.class)
+ setPath(InstanceIdentifier.create(MappingDatabase.class).child(VirtualNetworkIdentifier.class)
.child(Mapping.class));
LOG.trace("Registering Mapping listener.");
registerDataChangeListener();
LOG.trace("Key: {}", entry.getKey());
LOG.trace("Value: {}", mapping);
- mapSystem.addMapping(mapping.getOrigin(), mapping.getLispAddressContainer(),
- new EidToLocatorRecordBuilder(mapping).build());
+ mapSystem.addMapping(mapping.getOrigin(), mapping.getMappingRecord().getEid(),
+ mapping.getMappingRecord());
}
}
LOG.trace("Key: {}", entry.getKey());
LOG.trace("Value: {}", entry.getValue());
- mapSystem.addMapping(mapping.getOrigin(), mapping.getLispAddressContainer(),
- new EidToLocatorRecordBuilder(mapping).build());
+ mapSystem.addMapping(mapping.getOrigin(), mapping.getMappingRecord().getEid(),
+ mapping.getMappingRecord());
try {
notificationPublishService.putNotification(MSNotificationInputUtil.toMappingChanged(mapping, MappingChange.Updated));
} catch (InterruptedException e) {
LOG.trace("Key: {}", entry);
LOG.trace("Value: {}", dataObject);
- mapSystem.removeMapping(mapping.getOrigin(), mapping.getLispAddressContainer());
+ mapSystem.removeMapping(mapping.getOrigin(), mapping.getMappingRecord().getEid());
try {
notificationPublishService.putNotification(MSNotificationInputUtil.toMappingChanged(mapping, MappingChange.Removed));
} catch (InterruptedException e) {
import java.util.List;
import org.opendaylight.lispflowmapping.lisp.util.LispAddressStringifier;
-import org.opendaylight.lispflowmapping.lisp.util.MaskUtil;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.eidtolocatorrecords.EidToLocatorRecord;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.lispaddress.LispAddressContainer;
+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.mappingservice.rev150906.EidUri;
import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.mappingservice.rev150906.MappingOrigin;
import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.mappingservice.rev150906.SiteId;
import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.mappingservice.rev150906.db.instance.AuthenticationKeyBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.mappingservice.rev150906.db.instance.Mapping;
import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.mappingservice.rev150906.db.instance.MappingBuilder;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.mappingservice.rev150906.mapping.authkey.container.MappingAuthkey;
/**
* @author Florin Coras
*
*/
public class DSBEInputUtil {
- public static Mapping toMapping(MappingOrigin origin, LispAddressContainer key, SiteId siteId,
- EidToLocatorRecord record) {
+ public static Mapping toMapping(MappingOrigin origin, Eid key, SiteId siteId, MappingRecord record) {
List<SiteId> siteIds = (siteId != null) ? Arrays.asList(siteId) : null;
- return new MappingBuilder(record).setEid(new EidUri(LispAddressStringifier.getURIString(key)))
- .setOrigin(origin).setSiteId(siteIds).build();
+ return new MappingBuilder().setEidUri(new EidUri(LispAddressStringifier.getURIString(key)))
+ .setOrigin(origin).setSiteId(siteIds).setMappingRecord(record).build();
}
- public static Mapping toMapping(MappingOrigin origin, LispAddressContainer key) {
+ public static Mapping toMapping(MappingOrigin origin, Eid key) {
MappingBuilder mb = new MappingBuilder();
- mb.setEid(new EidUri(LispAddressStringifier.getURIString(key)));
+ mb.setEidUri(new EidUri(LispAddressStringifier.getURIString(key)));
mb.setOrigin(origin);
- mb.setMaskLength(MaskUtil.getMaskForAddress(key));
- mb.setLispAddressContainer(key);
return mb.build();
}
- public static AuthenticationKey toAuthenticationKey(LispAddressContainer key, String authKey) {
+ public static AuthenticationKey toAuthenticationKey(Eid key, MappingAuthkey authKey) {
AuthenticationKeyBuilder akb = new AuthenticationKeyBuilder();
- akb.setEid(new EidUri(LispAddressStringifier.getURIString(key)));
- akb.setLispAddressContainer(key);
- akb.setMaskLength(MaskUtil.getMaskForAddress(key));
- akb.setAuthkey(authKey);
+ akb.setEidUri(new EidUri(LispAddressStringifier.getURIString(key)));
+ akb.setEid(key);
+ akb.setMappingAuthkey(authKey);
return akb.build();
}
}
package org.opendaylight.lispflowmapping.implementation.util;
import org.opendaylight.lispflowmapping.lisp.util.LispAddressStringifier;
+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.InstanceId;
+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.EidUri;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.mappingservice.rev150906.IidUri;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.mappingservice.rev150906.VniUri;
import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.mappingservice.rev150906.MappingDatabase;
import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.mappingservice.rev150906.MappingOrigin;
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.AuthenticationKeyKey;
import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.mappingservice.rev150906.db.instance.Mapping;
import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.mappingservice.rev150906.db.instance.MappingKey;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.lispaddress.LispAddressContainer;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.lispaddress.lispaddresscontainer.Address;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.lispaddress.lispaddresscontainer.address.LcafSegment;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.mappingservice.rev150906.mapping.database.InstanceId;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.mappingservice.rev150906.mapping.database.InstanceIdKey;
+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.VirtualNetworkIdentifierKey;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
import com.google.common.base.Preconditions;
*
*/
public class InstanceIdentifierUtil {
- public static InstanceIdentifier<AuthenticationKey> createAuthenticationKeyIid(LispAddressContainer eid) {
+ public static InstanceIdentifier<AuthenticationKey> createAuthenticationKeyIid(Eid eid) {
Preconditions.checkNotNull(eid, "Key needs and EID entry!");
- InstanceIdKey iidKey = new InstanceIdKey(new IidUri(Long.toString(getLispInstanceId(eid))));
+ VirtualNetworkIdentifierKey vniKey = new VirtualNetworkIdentifierKey(new VniUri(Long.toString(getLispInstanceId(eid))));
AuthenticationKeyKey authKeyKey = new AuthenticationKeyKey(new EidUri(getURIAddressString(eid)));
return InstanceIdentifier.create(MappingDatabase.class)
- .child(InstanceId.class, iidKey).child(AuthenticationKey.class, authKeyKey);
+ .child(VirtualNetworkIdentifier.class, vniKey).child(AuthenticationKey.class, authKeyKey);
}
- public static InstanceIdentifier<Mapping> createMappingIid(LispAddressContainer eid, MappingOrigin orig) {
+ public static InstanceIdentifier<Mapping> createMappingIid(Eid eid, MappingOrigin orig) {
Preconditions.checkNotNull(eid, "Mapping needs an EID entry!");
- InstanceIdKey iidKey = new InstanceIdKey(new IidUri(Long.toString(getLispInstanceId(eid))));
+ VirtualNetworkIdentifierKey vniKey = new VirtualNetworkIdentifierKey(new VniUri(Long.toString(getLispInstanceId(eid))));
MappingKey eidKey = new MappingKey(new EidUri(getURIAddressString(eid)), orig);
return InstanceIdentifier.create(MappingDatabase.class)
- .child(InstanceId.class, iidKey).child(Mapping.class, eidKey);
+ .child(VirtualNetworkIdentifier.class, vniKey).child(Mapping.class, eidKey);
}
- private static long getLispInstanceId(LispAddressContainer container) {
- Address eid = container.getAddress();
- if (eid instanceof LcafSegment) {
- return ((LcafSegment) eid).getLcafSegmentAddr().getInstanceId();
+ private static long getLispInstanceId(Eid eid) {
+ Address address = eid.getAddress();
+ if (address instanceof InstanceId) {
+ return ((InstanceId) address).getInstanceId().getIid().getValue();
}
return 0L;
}
- private static String getURIAddressString(LispAddressContainer container) {
- return LispAddressStringifier.getURIString(container);
+ private static String getURIAddressString(Eid eid) {
+ return LispAddressStringifier.getURIString(eid);
}
}
import java.util.List;
import org.opendaylight.lispflowmapping.lisp.type.LispMessage;
-import org.opendaylight.lispflowmapping.lisp.util.LispAFIConvertor;
import org.opendaylight.lispflowmapping.lisp.util.LispAddressStringifier;
import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.AddMapping;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.EidToLocatorRecord;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.LcafApplicationDataAddress;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.LispAFIAddress;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.LispDistinguishedNameAddress;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.lispaddress.LispAddressContainer;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.lispaddress.lispaddresscontainer.address.distinguishedname.DistinguishedName;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.lispaddress.lispaddresscontainer.address.lcafkeyvalue.LcafKeyValueAddressAddr;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.lispsimpleaddress.PrimitiveAddress;
+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.mapregisternotification.MapRegister;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.transportaddress.TransportAddress;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.transportaddress.TransportAddressBuilder;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.rloc.container.Rloc;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.transport.address.TransportAddress;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.transport.address.TransportAddressBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.mappingservice.rev150906.EidUri;
import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.mappingservice.rev150906.MappingOrigin;
import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.mappingservice.rev150906.SiteId;
import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.mappingservice.rev150906.db.instance.MappingBuilder;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev100924.IpAddressBuilder;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev100924.PortNumber;
+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;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.lisp.address.types.rev151105.lisp.address.address.ApplicationData;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.lisp.address.types.rev151105.lisp.address.address.DistinguishedName;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.lisp.address.types.rev151105.lisp.address.address.Ipv4;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.lisp.address.types.rev151105.lisp.address.address.Ipv6;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.lisp.address.types.rev151105.lisp.address.address.KeyValueAddress;
public class LispNotificationHelper {
- public static TransportAddress getTransportAddressFromContainer(LispAddressContainer container) {
+ public static TransportAddress getTransportAddressFromRloc(Rloc rloc) {
TransportAddressBuilder tab = new TransportAddressBuilder();
- LispAFIAddress address = LispAFIConvertor.toAFI(container);
- if (address instanceof org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.lispaddress.lispaddresscontainer.address.ipv4.Ipv4Address) {
- tab.setIpAddress(IpAddressBuilder.getDefaultInstance(((org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.lispaddress.lispaddresscontainer.address.ipv4.Ipv4Address) address).getIpv4Address().getValue()));
+ Address address = rloc.getAddress();
+ if (address instanceof Ipv4) {
+ tab.setIpAddress(IpAddressBuilder.getDefaultInstance(((Ipv4) address).getIpv4().getValue()));
tab.setPort(new PortNumber(LispMessage.PORT_NUM));
- } else if (address instanceof org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.lispaddress.lispaddresscontainer.address.ipv6.Ipv6Address) {
- tab.setIpAddress(IpAddressBuilder.getDefaultInstance(((org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.lispaddress.lispaddresscontainer.address.ipv6.Ipv6Address) address).getIpv6Address().getValue()));
+ } else if (address instanceof Ipv6) {
+ tab.setIpAddress(IpAddressBuilder.getDefaultInstance(((Ipv6) address).getIpv6().getValue()));
tab.setPort(new PortNumber(LispMessage.PORT_NUM));
- } else if (address instanceof LcafKeyValueAddressAddr) {
- PrimitiveAddress primitiveAddress = ((LcafKeyValueAddressAddr) address).getValue().getPrimitiveAddress();
- if (primitiveAddress instanceof LispDistinguishedNameAddress) {
- String value = ((LispDistinguishedNameAddress) primitiveAddress).getDistinguishedName();
+ } else if (address instanceof KeyValueAddress) {
+ SimpleAddress sa = ((KeyValueAddress) address).getKeyValueAddress().getValue();
+ if (sa.getDistinguishedNameType() != null) {
+ String value = sa.getDistinguishedNameType().getValue();
String ip = value.split(":")[0];
int port = Integer.valueOf(value.split(":")[1]);
tab.setIpAddress(IpAddressBuilder.getDefaultInstance(ip));
}
} else if (address instanceof DistinguishedName) {
DistinguishedName dname = (DistinguishedName) address;
- String value = dname.getDistinguishedName();
+ String value = dname.getDistinguishedName().getValue();
String ip = value.split(":")[0];
int port = Integer.valueOf(value.split(":")[1]);
tab.setIpAddress(IpAddressBuilder.getDefaultInstance(ip));
tab.setPort(new PortNumber(port));
- } else if (address instanceof LcafApplicationDataAddress) {
- LcafApplicationDataAddress appData = (LcafApplicationDataAddress) address;
- tab.setIpAddress(IpAddressBuilder.getDefaultInstance(((org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.lispsimpleaddress.primitiveaddress.Ipv4) appData.getAddress().getPrimitiveAddress()).getIpv4Address()
- .getIpv4Address().getValue()));
- tab.setPort(new PortNumber(appData.getLocalPortLow()));
+ } else if (address instanceof ApplicationData) {
+ ApplicationData appData = (ApplicationData) address;
+ tab.setIpAddress(appData.getApplicationData().getAddress().getIpAddress());
+ tab.setPort(new PortNumber(appData.getApplicationData().getLocalPortLow()));
}
return tab.build();
}
public static List<Mapping> getMapping(AddMapping mapRegisterNotification) {
List<Mapping> mappings = new ArrayList<Mapping>();
- for (int i=0; i<mapRegisterNotification.getMapRegister().getEidToLocatorRecord().size(); i++) {
- EidToLocatorRecord record = mapRegisterNotification.getMapRegister().getEidToLocatorRecord().get(i);
+ for (int i=0; i<mapRegisterNotification.getMapRegister().getMappingRecordItem().size(); i++) {
+ MappingRecord record = mapRegisterNotification.getMapRegister().getMappingRecordItem().get(i).getMappingRecord();
MappingBuilder mb = new MappingBuilder();
- mb.setEid(new EidUri(LispAddressStringifier.getURIString(
- record.getLispAddressContainer())));
+ mb.setEidUri(new EidUri(LispAddressStringifier.getURIString(
+ record.getEid())));
mb.setOrigin(MappingOrigin.Southbound);
mb.setSiteId(getSiteId(mapRegisterNotification.getMapRegister()));
- mb.setRecordTtl(record.getRecordTtl());
- mb.setMaskLength(record.getMaskLength());
- mb.setMapVersion(record.getMapVersion());
- mb.setAction(record.getAction());
- mb.setAuthoritative(record.isAuthoritative());
- mb.setLispAddressContainer(record.getLispAddressContainer());
- mb.setLocatorRecord(record.getLocatorRecord());
+ mb.setMappingRecord(record);
mappings.add(mb.build());
}
return mappings;
package org.opendaylight.lispflowmapping.implementation.util;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.EidToLocatorRecord;
import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.mappingservice.rev150906.MappingChange;
import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.mappingservice.rev150906.MappingChanged;
import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.mappingservice.rev150906.MappingChangedBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.mappingservice.rev150906.db.instance.Mapping;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.mappingservice.rev150906.mapping.changed.MappingBuilder;
/**
* @author Florin Coras
public class MSNotificationInputUtil {
public static MappingChanged toMappingChanged(Mapping input, MappingChange change) {
- return new MappingChangedBuilder().setMapping(new MappingBuilder((EidToLocatorRecord) input).build())
- .setChange(change).build();
+ return new MappingChangedBuilder().setMappingRecord(input.getMappingRecord())
+ .setChangeType(change).build();
}
}
package org.opendaylight.lispflowmapping.implementation.util;
import org.opendaylight.lispflowmapping.lisp.util.LispAddressStringifier;
+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;
import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.mappingservice.rev150906.AddKeyInput;
import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.mappingservice.rev150906.AddMappingInput;
import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.mappingservice.rev150906.EidUri;
import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.mappingservice.rev150906.db.instance.AuthenticationKeyBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.mappingservice.rev150906.db.instance.Mapping;
import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.mappingservice.rev150906.db.instance.MappingBuilder;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.mappingservice.rev150906.mapping.authkey.container.MappingAuthkey;
/**
* Converts RPC *Input object to other object types
*/
public class RPCInputConvertorUtil {
public static AuthenticationKey toAuthenticationKey(AddKeyInput input) {
- AuthenticationKeyBuilder akb = new AuthenticationKeyBuilder();
- akb.setEid(new EidUri(LispAddressStringifier.getURIString(
- input.getLispAddressContainer())));
- akb.setLispAddressContainer(input.getLispAddressContainer());
- akb.setMaskLength(input.getMaskLength());
- akb.setKeyType(input.getKeyType());
- akb.setAuthkey(input.getAuthkey());
- return akb.build();
+ return toAuthenticationKey(input.getEid(), input.getMappingAuthkey());
}
public static AuthenticationKey toAuthenticationKey(UpdateKeyInput input) {
- AuthenticationKeyBuilder akb = new AuthenticationKeyBuilder();
- akb.setEid(new EidUri(LispAddressStringifier.getURIString(
- input.getEid().getLispAddressContainer())));
- akb.setLispAddressContainer(input.getEid().getLispAddressContainer());
- akb.setMaskLength(input.getEid().getMaskLength());
- akb.setKeyType(input.getKey().getKeyType());
- akb.setAuthkey(input.getKey().getAuthkey());
- return akb.build();
+ return toAuthenticationKey(input.getEid(), input.getMappingAuthkey());
}
public static AuthenticationKey toAuthenticationKey(RemoveKeyInput input) {
- AuthenticationKeyBuilder akb = new AuthenticationKeyBuilder();
- akb.setEid(new EidUri(LispAddressStringifier.getURIString(
- input.getLispAddressContainer())));
- akb.setLispAddressContainer(input.getLispAddressContainer());
- akb.setMaskLength(input.getMaskLength());
- return akb.build();
+ return toAuthenticationKey(input.getEid(), null);
}
public static Mapping toMapping(AddMappingInput input) {
- MappingBuilder mb = new MappingBuilder();
- mb.setEid(new EidUri(LispAddressStringifier.getURIString(
- input.getLispAddressContainer())));
- mb.setOrigin(MappingOrigin.Northbound);
- mb.setRecordTtl(input.getRecordTtl());
- mb.setMaskLength(input.getMaskLength());
- mb.setMapVersion(input.getMapVersion());
- mb.setAction(input.getAction());
- mb.setAuthoritative(input.isAuthoritative());
- mb.setLispAddressContainer(input.getLispAddressContainer());
- mb.setLocatorRecord(input.getLocatorRecord());
- return mb.build();
+ return toMapping(input.getMappingRecord());
}
public static Mapping toMapping(UpdateMappingInput input) {
+ return toMapping(input.getMappingRecord());
+ }
+
+ public static Mapping toMapping(RemoveMappingInput input) {
+ return toMapping(input.getEid());
+ }
+
+ private static AuthenticationKey toAuthenticationKey(Eid address, MappingAuthkey key) {
+ AuthenticationKeyBuilder akb = new AuthenticationKeyBuilder();
+ akb.setEidUri(new EidUri(LispAddressStringifier.getURIString(address)));
+ akb.setEid(address);
+ if (key != null) {
+ akb.setMappingAuthkey(key);
+ }
+ return akb.build();
+ }
+
+ private static Mapping toMapping(MappingRecord mapping) {
MappingBuilder mb = new MappingBuilder();
- mb.setEid(new EidUri(LispAddressStringifier.getURIString(
- input.getLispAddressContainer())));
+ mb.setEidUri(new EidUri(LispAddressStringifier.getURIString(mapping.getEid())));
mb.setOrigin(MappingOrigin.Northbound);
- mb.setRecordTtl(input.getRecordTtl());
- mb.setMaskLength(input.getMaskLength());
- mb.setMapVersion(input.getMapVersion());
- mb.setAction(input.getAction());
- mb.setAuthoritative(input.isAuthoritative());
- mb.setLispAddressContainer(input.getLispAddressContainer());
- mb.setLocatorRecord(input.getLocatorRecord());
+ mb.setMappingRecord(mapping);
return mb.build();
}
- public static Mapping toMapping(RemoveMappingInput input) {
+ private static Mapping toMapping(Eid eid) {
MappingBuilder mb = new MappingBuilder();
- mb.setEid(new EidUri(LispAddressStringifier.getURIString(
- input.getLispAddressContainer())));
+ mb.setEidUri(new EidUri(LispAddressStringifier.getURIString(eid)));
mb.setOrigin(MappingOrigin.Northbound);
- mb.setMaskLength(input.getMaskLength());
- mb.setLispAddressContainer(input.getLispAddressContainer());
+ mb.setMappingRecord(new MappingRecordBuilder().setEid(eid).build());
return mb.build();
}
}
import junitx.framework.ArrayAssert;
import org.junit.Test;
-import org.opendaylight.lispflowmapping.lisp.util.LispAFIConvertor;
+import org.opendaylight.lispflowmapping.lisp.util.LispAddressUtil;
import org.opendaylight.lispflowmapping.lisp.serializer.MapRegisterSerializer;
import org.opendaylight.lispflowmapping.tools.junit.BaseTestCase;
import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.MapRegister;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.eidtolocatorrecords.EidToLocatorRecord;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.eidtolocatorrecords.EidToLocatorRecordBuilder;
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.mapnotifymessage.MapNotifyBuilder;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.mapping.record.container.MappingRecordBuilder;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.mapping.record.list.MappingRecordItem;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.mapping.record.list.MappingRecordItemBuilder;
public class LispAuthenticationTest extends BaseTestCase {
public void authenticate__MapNotifyNoAuthenticationData() throws Exception {
MapNotifyBuilder mapNotifyBuilder = new MapNotifyBuilder();
mapNotifyBuilder.setKeyId((short) 0x0000);
- mapNotifyBuilder.setEidToLocatorRecord(new ArrayList<EidToLocatorRecord>());
- EidToLocatorRecordBuilder etlrBuilder = new EidToLocatorRecordBuilder();
+ mapNotifyBuilder.setMappingRecordItem(new ArrayList<MappingRecordItem>());
+ MappingRecordBuilder etlrBuilder = new MappingRecordBuilder();
etlrBuilder.setLocatorRecord(new ArrayList<LocatorRecord>());
- etlrBuilder.setLispAddressContainer(LispAFIConvertor.getIPContainer("1.1.1.1"));
+ etlrBuilder.setEid(LispAddressUtil.asIpv4PrefixEid("1.1.1.1/32"));
etlrBuilder.setRecordTtl(55);
- mapNotifyBuilder.getEidToLocatorRecord().add(etlrBuilder.build());
+ mapNotifyBuilder.getMappingRecordItem().add(
+ new MappingRecordItemBuilder().setMappingRecord(etlrBuilder.build()).build());
ArrayAssert.assertEquals(new byte[0], LispAuthenticationUtil.createAuthenticationData(mapNotifyBuilder.build(), "password"));
}
import org.opendaylight.lispflowmapping.implementation.MappingSystem;
import org.opendaylight.lispflowmapping.interfaces.dao.ILispDAO;
import org.opendaylight.lispflowmapping.interfaces.dao.SubKeys;
-import org.opendaylight.lispflowmapping.lisp.util.LispAFIConvertor;
+import org.opendaylight.lispflowmapping.lisp.util.LispAddressUtil;
import org.opendaylight.lispflowmapping.tools.junit.BaseTestCase;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.EidToLocatorRecord.Action;
import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.MapReply;
import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.MapRequest;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.eidrecords.EidRecord;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.eidrecords.EidRecordBuilder;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.eidtolocatorrecords.EidToLocatorRecord;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.eidtolocatorrecords.EidToLocatorRecordBuilder;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.lispaddress.LispAddressContainer;
+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.eid.list.EidItem;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.eid.list.EidItemBuilder;
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;
+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.MappingRecord.Action;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.mapping.record.container.MappingRecordBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.maprequest.ItrRloc;
import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.maprequest.SourceEidBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.maprequestnotification.MapRequestBuilder;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.rloc.container.Rloc;
public class MapResolverTest extends BaseTestCase {
private ILispDAO dao;
private MappingService mapService;
private MapRequestBuilder mapRequest;
- private LispAddressContainer v4Address;
- private LispAddressContainer v6Address;
+ private Eid v4Address;
+ private Eid v6Address;
- private HashMap<LispAddressContainer, Map<String, EidToLocatorRecord>> daoResults;
+ private HashMap<Eid, Map<String, MappingRecord>> daoResults;
@Override
@Before
testedMapResolver.basicInit();
mapRequest = new MapRequestBuilder();
- v4Address = LispAFIConvertor.asIPv4Address("1.2.3.4");
- v6Address = LispAFIConvertor.asIPv6Address("0:0:0:0:0:0:0:1");
- daoResults = new HashMap<LispAddressContainer, Map<String, EidToLocatorRecord>>();
+ v4Address = LispAddressUtil.asIpv4PrefixEid("1.2.3.4/32");
+ v6Address = LispAddressUtil.asIpv6PrefixEid("0:0:0:0:0:0:0:1/128");
+ daoResults = new HashMap<Eid, Map<String, MappingRecord>>();
}
@Test
public void handleMapRequest__ReplyWithSingleLocator() throws Exception {
mapRequest = getDefaultMapRequestBuilder();
- mapRequest.getEidRecord().add(
- new EidRecordBuilder().setMask((short) 32)
- .setLispAddressContainer(LispAFIConvertor.asIPv4Address("1.2.3.4")).build());
+ mapRequest.getEidItem().add(new EidItemBuilder().setEid(v4Address).build());
- EidToLocatorRecordBuilder record = getDefaultEidToLocatorBuilder();
- record.setLispAddressContainer(v4Address);
+ MappingRecordBuilder record = getDefaultMappingRecordBuilder();
+ record.setEid(v4Address);
LocatorRecordBuilder locator = getDefaultLocatorBuilder();
locator.setLocalLocator(false);
- locator.setLispAddressContainer(LispAFIConvertor.asIPv4Address("4.3.2.1"));
+ locator.setRloc(LispAddressUtil.asIpv4Rloc("4.3.2.1"));
locator.setRouted(true);
locator.setMulticastPriority((short) 5);
locator.setWeight((short) 17);
MapReply mapReply = testedMapResolver.handleMapRequest(mapRequest.build());
- EidToLocatorRecord eidToLocators = mapReply.getEidToLocatorRecord().get(0);
+ MappingRecord eidToLocators = mapReply.getMappingRecordItem().get(0).getMappingRecord();
assertEquals(1, eidToLocators.getLocatorRecord().size());
- LocatorRecord resultLocator = mapReply.getEidToLocatorRecord().get(0).getLocatorRecord().get(0);
+ LocatorRecord resultLocator = mapReply.getMappingRecordItem().get(0).getMappingRecord().getLocatorRecord().get(0);
assertEquals(locator.isLocalLocator(), resultLocator.isLocalLocator());
assertEquals(locator.isRouted(), resultLocator.isRouted());
assertEquals(locator.getMulticastPriority(), resultLocator.getMulticastPriority());
assertEquals(locator.getPriority(), resultLocator.getPriority());
assertEquals(locator.getWeight(), resultLocator.getWeight());
- assertLocator(LispAFIConvertor.asIPv4Address("4.3.2.1"), eidToLocators.getLocatorRecord().get(0));
+ assertLocator(LispAddressUtil.asIpv4Rloc("4.3.2.1"), eidToLocators.getLocatorRecord().get(0));
}
@Test
public void handleMapRequest__VerifyBasicFields() throws Exception {
mapRequest = getDefaultMapRequestBuilder();
- mapRequest.getEidRecord().add(
- new EidRecordBuilder().setMask((short) 32).setLispAddressContainer(v4Address).build());
+ mapRequest.getEidItem().add(new EidItemBuilder().setEid(v4Address).build());
- EidToLocatorRecordBuilder record = getDefaultEidToLocatorBuilder();
- record.setLispAddressContainer(v4Address);
+ MappingRecordBuilder record = getDefaultMappingRecordBuilder();
+ record.setEid(v4Address);
record.setRecordTtl(100);
record.setAuthoritative(true);
LocatorRecordBuilder locator = getDefaultLocatorBuilder();
- locator.setLispAddressContainer(LispAFIConvertor.asIPv4Address("4.3.2.1"));
+ locator.setRloc(LispAddressUtil.asIpv4Rloc("4.3.2.1"));
record.getLocatorRecord().add(locator.build());
prepareMapping(record.build());
MapReply mapReply = testedMapResolver.handleMapRequest(mapRequest.build());
assertEquals(mapRequest.getNonce(), mapReply.getNonce());
- EidToLocatorRecord eidToLocators = mapReply.getEidToLocatorRecord().get(0);
- assertEquals((byte) 32, eidToLocators.getMaskLength().byteValue());
- assertEquals(v4Address, eidToLocators.getLispAddressContainer());
+ MappingRecord eidToLocators = mapReply.getMappingRecordItem().get(0).getMappingRecord();
+ assertEquals(v4Address, eidToLocators.getEid());
assertEquals(record.isAuthoritative(), eidToLocators.isAuthoritative());
assertEquals(record.getAction(), eidToLocators.getAction());
assertEquals(record.getRecordTtl(), eidToLocators.getRecordTtl());
@Test
public void handleMapRequest__VerifyMask() throws Exception {
mapRequest = getDefaultMapRequestBuilder();
- mapRequest.getEidRecord().add(
- new EidRecordBuilder().setMask((short) 32).setLispAddressContainer(v4Address).build());
+ mapRequest.getEidItem().add(new EidItemBuilder().setEid(v4Address).build());
- EidToLocatorRecordBuilder record = getDefaultEidToLocatorBuilder();
- record.setLispAddressContainer(LispAFIConvertor.asIPv4Prefix("1.2.3.0", 24));
- record.setMaskLength((short) 24);
+ MappingRecordBuilder record = getDefaultMappingRecordBuilder();
+ record.setEid(LispAddressUtil.asIpv4PrefixEid("1.2.3.0/24"));
LocatorRecordBuilder locator = getDefaultLocatorBuilder();
- locator.setLispAddressContainer(LispAFIConvertor.toContainer(LispAFIConvertor.asIPAfiAddress("4.3.2.1")));
+ locator.setRloc(LispAddressUtil.asIpv4Rloc("4.3.2.1"));
record.getLocatorRecord().add(locator.build());
prepareMapping(record.build());
MapReply mapReply = testedMapResolver.handleMapRequest(mr);
assertEquals(mr.getNonce(), mapReply.getNonce());
- EidToLocatorRecord eidToLocators = mapReply.getEidToLocatorRecord().get(0);
- assertEquals((byte) 24, eidToLocators.getMaskLength().byteValue());
- assertEquals(LispAFIConvertor.asIPv4Prefix("1.2.3.0", 24), eidToLocators.getLispAddressContainer());
+ MappingRecord eidToLocators = mapReply.getMappingRecordItem().get(0).getMappingRecord();
+ assertEquals(LispAddressUtil.asIpv4PrefixEid("1.2.3.0/24"), eidToLocators.getEid());
}
@Test
public void handleMapRequest__VerifyMaskIPv6() throws Exception {
mapRequest = getDefaultMapRequestBuilder();
- mapRequest.getEidRecord().add(
- new EidRecordBuilder().setMask((short) 128).setLispAddressContainer(v6Address).build());
+ mapRequest.getEidItem().add(new EidItemBuilder().setEid(v6Address).build());
- EidToLocatorRecordBuilder record = getDefaultEidToLocatorBuilder();
- record.setLispAddressContainer(LispAFIConvertor.toContainer(LispAFIConvertor.asIPv6AfiAddress("0:0:0:0:0:0:0:0")));
- record.setMaskLength((short) 128);
+ MappingRecordBuilder record = getDefaultMappingRecordBuilder();
+ record.setEid(LispAddressUtil.asIpv6PrefixEid("0:0:0:0:0:0:0:0/128"));
LocatorRecordBuilder locator = getDefaultLocatorBuilder();
- locator.setLispAddressContainer(LispAFIConvertor.toContainer(LispAFIConvertor.asIPAfiAddress("4.3.2.1")));
+ locator.setRloc(LispAddressUtil.asIpv4Rloc("4.3.2.1"));
record.getLocatorRecord().add(locator.build());
prepareMapping(record.build());
MapReply mapReply = testedMapResolver.handleMapRequest(mr);
assertEquals(mr.getNonce(), mapReply.getNonce());
- EidToLocatorRecord eidToLocators = mapReply.getEidToLocatorRecord().get(0);
- assertEquals((byte) 128, eidToLocators.getMaskLength().byteValue());
- assertEquals(v6Address, eidToLocators.getLispAddressContainer());
+ MappingRecord eidToLocators = mapReply.getMappingRecordItem().get(0).getMappingRecord();
+ assertEquals(v6Address, eidToLocators.getEid());
}
@Test
public void handleMapRequest__VerifyMaskIPv6NoMatch() throws Exception {
mapRequest = getDefaultMapRequestBuilder();
- mapRequest.getEidRecord().add(
- new EidRecordBuilder().setMask((short) 128).setLispAddressContainer(v6Address).build());
+ mapRequest.getEidItem().add(new EidItemBuilder().setEid(v6Address).build());
- EidToLocatorRecordBuilder record = getDefaultEidToLocatorBuilder();
- record.setLispAddressContainer(LispAFIConvertor.asIPv6Prefix("0:1:0:0:0:0:0:1", 112));
- record.setMaskLength((short) 112);
+ MappingRecordBuilder record = getDefaultMappingRecordBuilder();
+ record.setEid(LispAddressUtil.asIpv6PrefixEid("0:1:0:0:0:0:0:1/112"));
LocatorRecordBuilder locator = getDefaultLocatorBuilder();
- locator.setLispAddressContainer(LispAFIConvertor.asIPv4Address("4.3.2.1"));
+ locator.setRloc(LispAddressUtil.asIpv4Rloc("4.3.2.1"));
record.getLocatorRecord().add(locator.build());
prepareMapping(record.build());
MapRequest mr = mapRequest.build();
MapReply mapReply = testedMapResolver.handleMapRequest(mr);
- EidToLocatorRecord eidToLocators = mapReply.getEidToLocatorRecord().get(0);
+ MappingRecord eidToLocators = mapReply.getMappingRecordItem().get(0).getMappingRecord();
assertEquals(null, eidToLocators.getLocatorRecord());
}
@Test
- public void handleMapRequest_VerifyNativelyForwardAutherized() {
+ public void handleMapRequest_VerifyNativelyForwardAuthorized() {
MapRequest mr = getDefaultMapRequest();
- Map<String, EidToLocatorRecord> result = new HashMap<String, EidToLocatorRecord>();
+ Map<String, MappingRecord> result = new HashMap<String, MappingRecord>();
result.put(SubKeys.RECORD, null);
MapReply mapReply = getNativelyForwardMapReply(mr, result);
- EidToLocatorRecord eidToLocators = mapReply.getEidToLocatorRecord().get(0);
+ MappingRecord eidToLocators = mapReply.getMappingRecordItem().get(0).getMappingRecord();
assertEquals(1, eidToLocators.getRecordTtl().intValue());
assertEquals(Action.NativelyForward, eidToLocators.getAction());
}
- private MapReply getNativelyForwardMapReply(MapRequest mr, Map<String, EidToLocatorRecord> result) {
- allowing(dao).get(wany(LispAddressContainer.class));
+ private MapReply getNativelyForwardMapReply(MapRequest mr, Map<String, MappingRecord> result) {
+ allowing(dao).get(wany(Eid.class));
ret(result);
- allowing(dao).getSpecific(wany(LispAddressContainer.class), with(SubKeys.AUTH_KEY));
+ allowing(dao).getSpecific(wany(Eid.class), with(SubKeys.AUTH_KEY));
ret("pass");
MapReply mapReply = testedMapResolver.handleMapRequest(mr);
return mapReply;
private MapRequest getDefaultMapRequest() {
mapRequest = getDefaultMapRequestBuilder();
- mapRequest.getEidRecord().add(
- new EidRecordBuilder().setMask((short) 32).setLispAddressContainer(v4Address).build());
+ mapRequest.getEidItem().add(new EidItemBuilder().setEid(v4Address).build());
MapRequest mr = mapRequest.build();
return mr;
}
@Test
public void handleMapRequest__VerifyMaskNoMatch() throws Exception {
mapRequest = getDefaultMapRequestBuilder();
- mapRequest.getEidRecord().add(
- new EidRecordBuilder().setMask((short) 32).setLispAddressContainer(v4Address).build());
+ mapRequest.getEidItem().add(new EidItemBuilder().setEid(v4Address).build());
- EidToLocatorRecordBuilder record = getDefaultEidToLocatorBuilder();
- record.setLispAddressContainer(LispAFIConvertor.asIPv4Prefix("1.2.4.0", 24));
- record.setMaskLength((short) 24);
+ MappingRecordBuilder record = getDefaultMappingRecordBuilder();
+ record.setEid(LispAddressUtil.asIpv4PrefixEid("1.2.4.0/24"));
LocatorRecordBuilder locator = getDefaultLocatorBuilder();
- locator.setLispAddressContainer(LispAFIConvertor.asIPv4Address("4.3.2.1"));
+ locator.setRloc(LispAddressUtil.asIpv4Rloc("4.3.2.1"));
record.getLocatorRecord().add(locator.build());
prepareMapping(record.build());
MapReply mapReply = testedMapResolver.handleMapRequest(mr);
- EidToLocatorRecord eidToLocators = mapReply.getEidToLocatorRecord().get(0);
+ MappingRecord eidToLocators = mapReply.getMappingRecordItem().get(0).getMappingRecord();
assertEquals(null, eidToLocators.getLocatorRecord());
}
public void handleMapRequest__ReplyWithMultipleLocators() throws Exception {
mapRequest = getDefaultMapRequestBuilder();
- mapRequest.getEidRecord().add(
- new EidRecordBuilder().setMask((short) 32).setLispAddressContainer(v4Address).build());
+ mapRequest.getEidItem().add(new EidItemBuilder().setEid(v4Address).build());
- EidToLocatorRecordBuilder record = getDefaultEidToLocatorBuilder();
- record.setLispAddressContainer(v4Address);
+ MappingRecordBuilder record = getDefaultMappingRecordBuilder();
+ record.setEid(v4Address);
LocatorRecordBuilder locator = getDefaultLocatorBuilder();
- locator.setLispAddressContainer(LispAFIConvertor.asIPv4Address("4.3.2.1"));
+ locator.setRloc(LispAddressUtil.asIpv4Rloc("4.3.2.1"));
record.getLocatorRecord().add(locator.build());
locator = getDefaultLocatorBuilder();
- locator.setLispAddressContainer(LispAFIConvertor.asIPv6Address("0:0:0:0:0:0:0:1"));
+ locator.setRloc(LispAddressUtil.asIpv6Rloc("0:0:0:0:0:0:0:1"));
record.getLocatorRecord().add(locator.build());
locator = getDefaultLocatorBuilder();
- locator.setLispAddressContainer(LispAFIConvertor.asIPv4Address("1.8.2.7"));
+ locator.setRloc(LispAddressUtil.asIpv4Rloc("1.8.2.7"));
record.getLocatorRecord().add(locator.build());
prepareMapping(record.build());
MapReply mapReply = testedMapResolver.handleMapRequest(mapRequest.build());
- EidToLocatorRecord eidToLocators = mapReply.getEidToLocatorRecord().get(0);
+ MappingRecord eidToLocators = mapReply.getMappingRecordItem().get(0).getMappingRecord();
assertEquals(3, eidToLocators.getLocatorRecord().size());
- assertLocator(LispAFIConvertor.asIPv4Address("4.3.2.1"), eidToLocators.getLocatorRecord().get(0));
- assertLocator(LispAFIConvertor.asIPv6Address("0:0:0:0:0:0:0:1"), eidToLocators.getLocatorRecord().get(1));
- assertLocator(LispAFIConvertor.asIPv4Address("1.8.2.7"), eidToLocators.getLocatorRecord().get(2));
+ assertLocator(LispAddressUtil.asIpv4Rloc("4.3.2.1"), eidToLocators.getLocatorRecord().get(0));
+ assertLocator(LispAddressUtil.asIpv6Rloc("0:0:0:0:0:0:0:1"), eidToLocators.getLocatorRecord().get(1));
+ assertLocator(LispAddressUtil.asIpv4Rloc("1.8.2.7"), eidToLocators.getLocatorRecord().get(2));
}
@Test
public void handleMapRequest__MultipleEIDs() throws Exception {
mapRequest = getDefaultMapRequestBuilder();
- mapRequest.getEidRecord().add(
- new EidRecordBuilder().setMask((short) 32).setLispAddressContainer(v4Address).build());
- mapRequest.getEidRecord().add(
- new EidRecordBuilder().setMask((short) 128).setLispAddressContainer(v6Address).build());
+ mapRequest.getEidItem().add(new EidItemBuilder().setEid(v4Address).build());
+ mapRequest.getEidItem().add(new EidItemBuilder().setEid(v6Address).build());
- EidToLocatorRecordBuilder record1 = getDefaultEidToLocatorBuilder();
- record1.setLispAddressContainer(v4Address);
+ MappingRecordBuilder record1 = getDefaultMappingRecordBuilder();
+ record1.setEid(v4Address);
record1.setRecordTtl(100);
LocatorRecordBuilder locator1 = getDefaultLocatorBuilder();
- locator1.setLispAddressContainer(LispAFIConvertor.toContainer(LispAFIConvertor.asIPAfiAddress("4.3.2.1")));
+ locator1.setRloc(LispAddressUtil.asIpv4Rloc("4.3.2.1"));
record1.getLocatorRecord().add(locator1.build());
- EidToLocatorRecordBuilder record2 = getDefaultEidToLocatorBuilder();
- record2.setLispAddressContainer(v6Address);
- record2.setMaskLength((short) 128);
+ MappingRecordBuilder record2 = getDefaultMappingRecordBuilder();
+ record2.setEid(v6Address);
record2.setRecordTtl(100);
LocatorRecordBuilder locator2 = getDefaultLocatorBuilder();
- locator2.setLispAddressContainer(LispAFIConvertor.toContainer(LispAFIConvertor.asIPv6AfiAddress("0:0:0:0:0:0:0:1")));
+ locator2.setRloc(LispAddressUtil.asIpv6Rloc("0:0:0:0:0:0:0:1"));
record2.getLocatorRecord().add(locator2.build());
prepareMapping(record1.build(), record2.build());
MapReply mapReply = testedMapResolver.handleMapRequest(mapRequest.build());
- EidToLocatorRecord eidToLocators1 = mapReply.getEidToLocatorRecord().get(0);
+ MappingRecord eidToLocators1 = mapReply.getMappingRecordItem().get(0).getMappingRecord();
assertEquals(1, eidToLocators1.getLocatorRecord().size());
- assertLocator(LispAFIConvertor.toContainer(LispAFIConvertor.asIPAfiAddress("4.3.2.1")), eidToLocators1
- .getLocatorRecord().get(0));
+ assertLocator(LispAddressUtil.asIpv4Rloc("4.3.2.1"), eidToLocators1.getLocatorRecord().get(0));
- EidToLocatorRecord eidToLocators2 = mapReply.getEidToLocatorRecord().get(1);
+ MappingRecord eidToLocators2 = mapReply.getMappingRecordItem().get(1).getMappingRecord();
assertEquals(1, eidToLocators2.getLocatorRecord().size());
- assertLocator(LispAFIConvertor.toContainer(LispAFIConvertor.asIPv6AfiAddress("0:0:0:0:0:0:0:1")), eidToLocators2
- .getLocatorRecord().get(0));
+ assertLocator(LispAddressUtil.asIpv6Rloc("0:0:0:0:0:0:0:1"), eidToLocators2.getLocatorRecord().get(0));
}
- private void assertLocator(LispAddressContainer expectedAddress, LocatorRecord locatorRecord) {
- assertEquals(expectedAddress, locatorRecord.getLispAddressContainer());
+ private void assertLocator(Rloc expectedAddress, LocatorRecord locatorRecord) {
+ assertEquals(expectedAddress, locatorRecord.getRloc());
Assert.assertTrue(locatorRecord.isRouted());
}
- private Map<String, EidToLocatorRecord> prepareMapping(EidToLocatorRecord... records) {
+ private Map<String, MappingRecord> prepareMapping(MappingRecord... records) {
if (records.length > 0) {
- for (EidToLocatorRecord eidToLocatorRecord : records) {
- Map<String, EidToLocatorRecord> result = new HashMap<String, EidToLocatorRecord>();
+ for (MappingRecord eidToLocatorRecord : records) {
+ Map<String, MappingRecord> result = new HashMap<String, MappingRecord>();
result.put(SubKeys.RECORD, eidToLocatorRecord);
- daoResults.put(eidToLocatorRecord.getLispAddressContainer(), result);
+ daoResults.put(eidToLocatorRecord.getEid(), result);
}
}
- ValueSaverAction<LispAddressContainer> daoGetSaverAction = new ValueSaverAction<LispAddressContainer>() {
+ ValueSaverAction<Eid> daoGetSaverAction = new ValueSaverAction<Eid>() {
@Override
- protected boolean validate(LispAddressContainer value) {
+ protected boolean validate(Eid value) {
return true;
}
allowing(dao).get(with(daoGetSaverAction));
will(daoGetSaverAction);
- allowing(dao).getSpecific(wany(LispAddressContainer.class), with(SubKeys.AUTH_KEY));
+ allowing(dao).getSpecific(wany(Eid.class), with(SubKeys.AUTH_KEY));
return daoResults.get(v4Address);
}
private MapRequestBuilder getDefaultMapRequestBuilder() {
MapRequestBuilder mrBuilder = new MapRequestBuilder();
mrBuilder.setAuthoritative(false);
- mrBuilder.setEidRecord(new ArrayList<EidRecord>());
+ mrBuilder.setEidItem(new ArrayList<EidItem>());
mrBuilder.setItrRloc(new ArrayList<ItrRloc>());
mrBuilder.setMapDataPresent(true);
mrBuilder.setNonce((long) 0);
mrBuilder.setProbe(false);
mrBuilder.setSmr(false);
mrBuilder.setSmrInvoked(true);
- mrBuilder.setSourceEid(new SourceEidBuilder().setLispAddressContainer(
- LispAFIConvertor.toContainer(LispAFIConvertor.asIPAfiAddress("127.0.0.1"))).build());
+ mrBuilder.setSourceEid(new SourceEidBuilder().setEid(LispAddressUtil.asIpv4Eid("127.0.0.1")).build());
return mrBuilder;
}
- private EidToLocatorRecordBuilder getDefaultEidToLocatorBuilder() {
- EidToLocatorRecordBuilder builder = new EidToLocatorRecordBuilder();
+ private MappingRecordBuilder getDefaultMappingRecordBuilder() {
+ MappingRecordBuilder builder = new MappingRecordBuilder();
builder.setAction(Action.NoAction);
builder.setAuthoritative(false);
builder.setLocatorRecord(new ArrayList<LocatorRecord>());
builder.setMapVersion((short) 0);
- builder.setMaskLength((short) 32);
builder.setRecordTtl(60);
return builder;
}
import org.opendaylight.lispflowmapping.interfaces.dao.ILispDAO;
import org.opendaylight.lispflowmapping.interfaces.dao.MappingEntry;
import org.opendaylight.lispflowmapping.interfaces.dao.SubKeys;
-import org.opendaylight.lispflowmapping.lisp.util.LispAFIConvertor;
+import org.opendaylight.lispflowmapping.lisp.util.LispAddressUtil;
import org.opendaylight.lispflowmapping.lisp.util.MaskUtil;
import org.opendaylight.lispflowmapping.lisp.serializer.MapRegisterSerializer;
import org.opendaylight.lispflowmapping.tools.junit.BaseTestCase;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.EidToLocatorRecord.Action;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.LispAFIAddress;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.lisp.address.types.rev151105.NoAddressAfi;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.lisp.address.types.rev151105.SimpleAddressBuilder;
+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.NoAddressBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.MapNotify;
import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.MapRegister;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.eidtolocatorrecords.EidToLocatorRecord;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.eidtolocatorrecords.EidToLocatorRecordBuilder;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.lispaddress.LispAddressContainer;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.lispaddress.lispaddresscontainer.address.no.NoAddressBuilder;
+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.eid.container.EidBuilder;
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;
+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.MappingRecord.Action;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.mapping.record.container.MappingRecordBuilder;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.mapping.record.list.MappingRecordItem;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.mapping.record.list.MappingRecordItemBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.mapregisternotification.MapRegisterBuilder;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.rloc.container.Rloc;
import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.mappingservice.rev150906.MappingOrigin;
import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.mappingservice.rev150906.db.instance.Mapping;
private MappingSystem mapSystem;
private MapRegisterBuilder mapRegisterBuilder;
- private LispAddressContainer eid;
- private LispAddressContainer rloc;
+ private Eid eid;
+ private Rloc rloc;
private ValueSaverAction<MappingEntry<?>[]> mappingEntriesSaver;
private MapRegister mapRegisterWithAuthentication;
- private String eidIpv4String = "10.31.0.5";
- private String eidIpv6String = "1:1:1:1:1:1:1:0";
+ private String eidIpv4String = "10.31.0.5/32";
+ private String eidIpv6String = "1:1:1:1:1:1:1:0/128";
@Override
@Before
mapRegisterBuilder = new MapRegisterBuilder();
mapRegisterBuilder.setKeyId((short) 0);
mapRegisterBuilder.setAuthenticationData(new byte[0]);
- eid = LispAFIConvertor.asIPv4Address(eidIpv4String);
- rloc = LispAFIConvertor.asIPv4Address("192.168.136.10");
- EidToLocatorRecordBuilder recordBuilder = new EidToLocatorRecordBuilder();
- recordBuilder.setLispAddressContainer(eid).setMaskLength((short) 32);
+ eid = LispAddressUtil.asIpv4PrefixEid(eidIpv4String);
+ rloc = LispAddressUtil.asIpv4Rloc("192.168.136.10");
+ MappingRecordBuilder recordBuilder = new MappingRecordBuilder();
+ recordBuilder.setEid(eid);
recordBuilder.setLocatorRecord(new ArrayList<LocatorRecord>());
- recordBuilder.getLocatorRecord().add(new LocatorRecordBuilder().setLispAddressContainer(rloc).build());
+ recordBuilder.getLocatorRecord().add(new LocatorRecordBuilder().setRloc(rloc).build());
recordBuilder.setAction(Action.NoAction).setMapVersion((short) 0).setAuthoritative(false).setRecordTtl(60).setMaskLength((short) 32);
- mapRegisterBuilder.setEidToLocatorRecord(new ArrayList<EidToLocatorRecord>());
- mapRegisterBuilder.getEidToLocatorRecord().add(recordBuilder.build());
+ mapRegisterBuilder.setMappingRecordItem(new ArrayList<MappingRecordItem>());
+ mapRegisterBuilder.getMappingRecordItem().add(new MappingRecordItemBuilder().setMappingRecord(recordBuilder.build()).build());
mapRegisterWithAuthentication = MapRegisterSerializer.getInstance().deserialize(hexToByteBuffer("38 00 01 01 FF BB "
//
+ "00 00 00 00 00 00 00 01 00 14 2c 61 b9 c9 9a 20 " //
MappingEntry<?>[] entries = mappingEntriesSaver.lastValue;
assertEquals(1, entries.length);
assertEquals(SubKeys.RECORD, entries[0].getKey());
- assertEquals(rloc, ((EidToLocatorRecord) entries[0].getValue())
- .getLocatorRecord().get(0).getLispAddressContainer());
+ assertEquals(rloc, ((MappingRecord) entries[0].getValue()).getLocatorRecord().get(0).getRloc());
}
@Test
public void handleMapRegisterIpv4__ValidNotifyEchoesRegister() throws Exception {
- mapRegisterBuilder.getEidToLocatorRecord().add(
- getDefaultEidToLocatorBuilder().setLispAddressContainer(LispAFIConvertor.toContainer(new NoAddressBuilder().build())).build());
+ mapRegisterBuilder.getMappingRecordItem().add(new MappingRecordItemBuilder().setMappingRecord(
+ getDefaultMappingRecordBuilder().setEid(new EidBuilder().setAddressType(NoAddressAfi.class).setAddress(
+ (Address) new NoAddressBuilder().setNoAddress(true).build()).build()).build()).build());
mapRegisterBuilder.setWantMapNotify(true);
addDefaultPutAndGetExpectations(eid);
- addDefaultPutAndGetExpectations(LispAFIConvertor.toContainer(new NoAddressBuilder().build()));
+ addDefaultPutAndGetExpectations(new EidBuilder().setAddressType(NoAddressAfi.class).setAddress(
+ (Address) new NoAddressBuilder().setNoAddress(true).build()).build());
MapRegister mr = mapRegisterBuilder.build();
MapNotify mapNotify = testedMapServer.handleMapRegister(mr);
- assertEquals(mr.getEidToLocatorRecord(), mapNotify.getEidToLocatorRecord());
+ assertEquals(mr.getMappingRecordItem(), mapNotify.getMappingRecordItem());
ArrayAssert.assertEquals(mr.getAuthenticationData(), mapNotify.getAuthenticationData());
assertEquals(mr.getKeyId(), mapNotify.getKeyId());
assertEquals(mr.getNonce(), mapNotify.getNonce());
public void handleMapRegisterIpv4__CloneNotOwnYouClown() throws Exception {
mapRegisterBuilder = getDefaultMapRegisterBuilder();
mapRegisterBuilder.setWantMapNotify(true);
- EidToLocatorRecordBuilder eidToLocatorBuilder = getDefaultEidToLocatorBuilder();
+ MappingRecordBuilder eidToLocatorBuilder = getDefaultMappingRecordBuilder();
eidToLocatorBuilder.setMaskLength((short) 32);
- eid = LispAFIConvertor.asIPv4Address("0.0.0.1");
- eidToLocatorBuilder.setLispAddressContainer(eid);
+ eid = LispAddressUtil.asIpv4PrefixEid("0.0.0.1/32");
+ eidToLocatorBuilder.setEid(eid);
LocatorRecordBuilder locatorBuilder = getDefaultLocatorBuilder();
- locatorBuilder.setLispAddressContainer(LispAFIConvertor.toContainer(LispAFIConvertor.asIPAfiAddress("0.0.0.2")));
+ locatorBuilder.setRloc(LispAddressUtil.asIpv4Rloc("0.0.0.2"));
locatorBuilder.setPriority((short) 55);
eidToLocatorBuilder.getLocatorRecord().add(locatorBuilder.build());
- mapRegisterBuilder.getEidToLocatorRecord().add(eidToLocatorBuilder.build());
+ mapRegisterBuilder.getMappingRecordItem().add(new MappingRecordItemBuilder().setMappingRecord(eidToLocatorBuilder.build()).build());
addDefaultPutAndGetExpectations(eid);
MapNotify mapNotify = testedMapServer.handleMapRegister(mapRegisterBuilder.build());
- EidToLocatorRecord actualEidToLocator = mapNotify.getEidToLocatorRecord().get(0);
- assertEquals(eid, actualEidToLocator.getLispAddressContainer());
+ MappingRecord actualEidToLocator = mapNotify.getMappingRecordItem().get(0).getMappingRecord();
+ assertEquals(eid, actualEidToLocator.getEid());
assertEquals((byte) 55, actualEidToLocator.getLocatorRecord().get(0).getPriority().byteValue());
}
@Test
public void handleMapRegisterIpv4__ValidMask() throws Exception {
int mask = 16;
- LispAddressContainer newEid = LispAFIConvertor.asIPv4Prefix(eidIpv4String, mask);
+ Eid newEid = LispAddressUtil.asIpv4PrefixEid(eidIpv4String + "/" + mask);
mapRegisterBuilder = getDefaultMapRegisterBuilder();
- EidToLocatorRecordBuilder recordBuilder = getDefaultEidToLocatorBuilder();
- recordBuilder.setLispAddressContainer(newEid).setMaskLength((short) mask);
+ MappingRecordBuilder recordBuilder = getDefaultMappingRecordBuilder();
+ recordBuilder.setEid(newEid).setMaskLength((short) mask);
LocatorRecordBuilder locator = getDefaultLocatorBuilder();
- locator.setLispAddressContainer(rloc);
+ locator.setRloc(rloc);
recordBuilder.getLocatorRecord().add(locator.build());
- mapRegisterBuilder.getEidToLocatorRecord().add(recordBuilder.build());
+ mapRegisterBuilder.getMappingRecordItem().add(new MappingRecordItemBuilder().setMappingRecord(recordBuilder.build()).build());
mapRegisterBuilder.setWantMapNotify(true);
MapRegister mr = mapRegisterBuilder.build();
addDefaultPutAndGetExpectations(newEid);
MapNotify mapNotify = testedMapServer.handleMapRegister(mr);
- assertEquals(newEid, mapNotify.getEidToLocatorRecord().get(0).getLispAddressContainer());
+ assertEquals(newEid, mapNotify.getMappingRecordItem().get(0).getMappingRecord().getEid());
ArrayAssert.assertEquals(mr.getAuthenticationData(), mapNotify.getAuthenticationData());
- assertEquals(mr.getEidToLocatorRecord(), mapNotify.getEidToLocatorRecord());
+ assertEquals(mr.getMappingRecordItem(), mapNotify.getMappingRecordItem());
assertEquals(mr.getKeyId(), mapNotify.getKeyId());
assertEquals(mr.getNonce(), mapNotify.getNonce());
}
public void handleMapRegister__NonMaskable() throws Exception {
int mask = 16;
mapRegisterBuilder = getDefaultMapRegisterBuilder();
- LispAddressContainer addr = LispAFIConvertor.toContainer(LispAFIConvertor.asMacAfiAddress("01:01:01:01:01:01"));
- EidToLocatorRecordBuilder recordBuilder = getDefaultEidToLocatorBuilder();
+ Eid addr = LispAddressUtil.asMacEid("01:01:01:01:01:01");
+ MappingRecordBuilder recordBuilder = getDefaultMappingRecordBuilder();
LocatorRecordBuilder locatorBuilder = getDefaultLocatorBuilder();
- locatorBuilder.setLispAddressContainer(rloc);
- recordBuilder.setLispAddressContainer(addr).setMaskLength((short) mask);
+ locatorBuilder.setRloc(rloc);
+ recordBuilder.setEid(addr).setMaskLength((short) mask);
recordBuilder.getLocatorRecord().add(locatorBuilder.build());
- mapRegisterBuilder.getEidToLocatorRecord().add(recordBuilder.build());
+ mapRegisterBuilder.getMappingRecordItem().add(new MappingRecordItemBuilder().setMappingRecord(recordBuilder.build()).build());
mapRegisterBuilder.setWantMapNotify(true);
addDefaultPutAndGetExpectations(addr);
MapRegister mapRegister = mapRegisterBuilder.build();
MapNotify mapNotify = testedMapServer.handleMapRegister(mapRegister);
- assertEquals(addr, mapNotify.getEidToLocatorRecord().get(0).getLispAddressContainer());
+ assertEquals(addr, mapNotify.getMappingRecordItem().get(0).getMappingRecord().getEid());
ArrayAssert.assertEquals(mapRegister.getAuthenticationData(), mapNotify.getAuthenticationData());
- assertEquals(mapRegister.getEidToLocatorRecord(), mapNotify.getEidToLocatorRecord());
+ assertEquals(mapRegister.getMappingRecordItem(), mapNotify.getMappingRecordItem());
assertEquals(mapRegister.getKeyId(), mapNotify.getKeyId());
assertEquals(mapRegister.getNonce(), mapNotify.getNonce());
}
public void handleMapRegister__ZeroMask() throws Exception {
int mask = 0;
mapRegisterBuilder = getDefaultMapRegisterBuilder();
- LispAddressContainer addr = LispAFIConvertor.toContainer(LispAFIConvertor.asMacAfiAddress("01:01:01:01:01:01"));
- EidToLocatorRecordBuilder recordBuilder = getDefaultEidToLocatorBuilder();
+ Eid addr = LispAddressUtil.asMacEid("01:01:01:01:01:01");
+ MappingRecordBuilder recordBuilder = getDefaultMappingRecordBuilder();
LocatorRecordBuilder locatorBuilder = getDefaultLocatorBuilder();
- locatorBuilder.setLispAddressContainer(rloc);
- recordBuilder.setLispAddressContainer(addr).setMaskLength((short) mask);
+ locatorBuilder.setRloc(rloc);
+ recordBuilder.setEid(addr).setMaskLength((short) mask);
recordBuilder.getLocatorRecord().add(locatorBuilder.build());
- mapRegisterBuilder.getEidToLocatorRecord().add(recordBuilder.build());
+ mapRegisterBuilder.getMappingRecordItem().add(new MappingRecordItemBuilder().setMappingRecord(recordBuilder.build()).build());
mapRegisterBuilder.setWantMapNotify(true);
addDefaultPutAndGetExpectations(addr);
MapRegister mapRegister = mapRegisterBuilder.build();
MapNotify mapNotify = testedMapServer.handleMapRegister(mapRegister);
- assertEquals(addr, mapNotify.getEidToLocatorRecord().get(0).getLispAddressContainer());
+ assertEquals(addr, mapNotify.getMappingRecordItem().get(0).getMappingRecord().getEid());
ArrayAssert.assertEquals(mapRegister.getAuthenticationData(), mapNotify.getAuthenticationData());
- assertEquals(mapRegister.getEidToLocatorRecord(), mapNotify.getEidToLocatorRecord());
+ assertEquals(mapRegister.getMappingRecordItem(), mapNotify.getMappingRecordItem());
assertEquals(mapRegister.getKeyId(), mapNotify.getKeyId());
assertEquals(mapRegister.getNonce(), mapNotify.getNonce());
}
@Test
public void handleMapRegisterIPv4__ZeroMask() throws Exception {
int mask = 0;
- LispAddressContainer newEid = LispAFIConvertor.asIPv4Prefix(eidIpv4String, mask);
+ Eid newEid = LispAddressUtil.asIpv4PrefixEid(eidIpv4String + "/" + mask);
mapRegisterBuilder = getDefaultMapRegisterBuilder();
- EidToLocatorRecordBuilder recordBuilder = getDefaultEidToLocatorBuilder();
- recordBuilder.setLispAddressContainer(newEid).setMaskLength((short) mask);
+ MappingRecordBuilder recordBuilder = getDefaultMappingRecordBuilder();
+ recordBuilder.setEid(newEid).setMaskLength((short) mask);
LocatorRecordBuilder locator = getDefaultLocatorBuilder();
- locator.setLispAddressContainer(rloc);
+ locator.setRloc(rloc);
recordBuilder.getLocatorRecord().add(locator.build());
- mapRegisterBuilder.getEidToLocatorRecord().add(recordBuilder.build());
+ mapRegisterBuilder.getMappingRecordItem().add(new MappingRecordItemBuilder().setMappingRecord(recordBuilder.build()).build());
mapRegisterBuilder.setWantMapNotify(true);
MapRegister mr = mapRegisterBuilder.build();
addDefaultPutAndGetExpectations(newEid);
MapNotify mapNotify = testedMapServer.handleMapRegister(mr);
- assertEquals(newEid, mapNotify.getEidToLocatorRecord().get(0).getLispAddressContainer());
+ assertEquals(newEid, mapNotify.getMappingRecordItem().get(0).getMappingRecord().getEid());
ArrayAssert.assertEquals(mr.getAuthenticationData(), mapNotify.getAuthenticationData());
- assertEquals(mr.getEidToLocatorRecord(), mapNotify.getEidToLocatorRecord());
+ assertEquals(mr.getMappingRecordItem(), mapNotify.getMappingRecordItem());
assertEquals(mr.getKeyId(), mapNotify.getKeyId());
assertEquals(mr.getNonce(), mapNotify.getNonce());
}
public void handleMapRegisterIpv4__ValidMask32() throws Exception {
int mask = 32;
mapRegisterBuilder = getDefaultMapRegisterBuilder();
- EidToLocatorRecordBuilder recordBuilder = getDefaultEidToLocatorBuilder();
- recordBuilder.setLispAddressContainer(eid).setMaskLength((short) mask);
+ MappingRecordBuilder recordBuilder = getDefaultMappingRecordBuilder();
+ recordBuilder.setEid(eid).setMaskLength((short) mask);
LocatorRecordBuilder locator = getDefaultLocatorBuilder();
- locator.setLispAddressContainer(rloc);
+ locator.setRloc(rloc);
recordBuilder.getLocatorRecord().add(locator.build());
- mapRegisterBuilder.getEidToLocatorRecord().add(recordBuilder.build());
+ mapRegisterBuilder.getMappingRecordItem().add(new MappingRecordItemBuilder().setMappingRecord(recordBuilder.build()).build());
mapRegisterBuilder.setWantMapNotify(true);
MapRegister mr = mapRegisterBuilder.build();
addDefaultPutAndGetExpectations(eid);
MapNotify mapNotify = testedMapServer.handleMapRegister(mr);
- assertEquals(eid, mapNotify.getEidToLocatorRecord().get(0).getLispAddressContainer());
+ assertEquals(eid, mapNotify.getMappingRecordItem().get(0).getMappingRecord().getEid());
ArrayAssert.assertEquals(mr.getAuthenticationData(), mapNotify.getAuthenticationData());
- assertEquals(mr.getEidToLocatorRecord(), mapNotify.getEidToLocatorRecord());
+ assertEquals(mr.getMappingRecordItem(), mapNotify.getMappingRecordItem());
assertEquals(mr.getKeyId(), mapNotify.getKeyId());
assertEquals(mr.getNonce(), mapNotify.getNonce());
}
public void handleMapRegisterIpv6__ValidMask96() throws Exception {
int mask = 96;
mapRegisterBuilder = getDefaultMapRegisterBuilder();
- LispAddressContainer addr = LispAFIConvertor.asIPv6Prefix(eidIpv6String, mask);
- EidToLocatorRecordBuilder recordBuilder = getDefaultEidToLocatorBuilder();
+ Eid addr = LispAddressUtil.asIpv6PrefixEid(eidIpv6String + "/" + mask);
+ MappingRecordBuilder recordBuilder = getDefaultMappingRecordBuilder();
LocatorRecordBuilder locatorBuilder = getDefaultLocatorBuilder();
- locatorBuilder.setLispAddressContainer(rloc);
- recordBuilder.setLispAddressContainer(addr).setMaskLength((short) mask);
+ locatorBuilder.setRloc(rloc);
+ recordBuilder.setEid(addr).setMaskLength((short) mask);
recordBuilder.getLocatorRecord().add(locatorBuilder.build());
- mapRegisterBuilder.getEidToLocatorRecord().add(recordBuilder.build());
+ mapRegisterBuilder.getMappingRecordItem().add(new MappingRecordItemBuilder().setMappingRecord(recordBuilder.build()).build());
mapRegisterBuilder.setWantMapNotify(true);
addDefaultPutAndGetExpectations(addr);
MapRegister mapRegister = mapRegisterBuilder.build();
MapNotify mapNotify = testedMapServer.handleMapRegister(mapRegister);
- assertEquals(addr, mapNotify.getEidToLocatorRecord().get(0).getLispAddressContainer());
+ assertEquals(addr, mapNotify.getMappingRecordItem().get(0).getMappingRecord().getEid());
ArrayAssert.assertEquals(mapRegister.getAuthenticationData(), mapNotify.getAuthenticationData());
- assertEquals(mapRegister.getEidToLocatorRecord(), mapNotify.getEidToLocatorRecord());
+ assertEquals(mapRegister.getMappingRecordItem(), mapNotify.getMappingRecordItem());
assertEquals(mapRegister.getKeyId(), mapNotify.getKeyId());
assertEquals(mapRegister.getNonce(), mapNotify.getNonce());
}
public void handleMapRegisterIpv6__ZeroMask() throws Exception {
int mask = 0;
mapRegisterBuilder = getDefaultMapRegisterBuilder();
- LispAddressContainer addr = LispAFIConvertor.asIPv6Prefix(eidIpv6String, mask);
- EidToLocatorRecordBuilder recordBuilder = getDefaultEidToLocatorBuilder();
+ Eid addr = LispAddressUtil.asIpv6PrefixEid(eidIpv6String + "/" + mask);
+ MappingRecordBuilder recordBuilder = getDefaultMappingRecordBuilder();
LocatorRecordBuilder locatorBuilder = getDefaultLocatorBuilder();
- locatorBuilder.setLispAddressContainer(rloc);
- recordBuilder.setLispAddressContainer(addr).setMaskLength((short) mask);
+ locatorBuilder.setRloc(rloc);
+ recordBuilder.setEid(addr).setMaskLength((short) mask);
recordBuilder.getLocatorRecord().add(locatorBuilder.build());
- mapRegisterBuilder.getEidToLocatorRecord().add(recordBuilder.build());
+ mapRegisterBuilder.getMappingRecordItem().add(new MappingRecordItemBuilder().setMappingRecord(recordBuilder.build()).build());
mapRegisterBuilder.setWantMapNotify(true);
addDefaultPutAndGetExpectations(addr);
MapRegister mapRegister = mapRegisterBuilder.build();
MapNotify mapNotify = testedMapServer.handleMapRegister(mapRegister);
- assertEquals(addr, mapNotify.getEidToLocatorRecord().get(0).getLispAddressContainer());
+ assertEquals(addr, mapNotify.getMappingRecordItem().get(0).getMappingRecord().getEid());
ArrayAssert.assertEquals(mapRegister.getAuthenticationData(), mapNotify.getAuthenticationData());
- assertEquals(mapRegister.getEidToLocatorRecord(), mapNotify.getEidToLocatorRecord());
+ assertEquals(mapRegister.getMappingRecordItem(), mapNotify.getMappingRecordItem());
assertEquals(mapRegister.getKeyId(), mapNotify.getKeyId());
assertEquals(mapRegister.getNonce(), mapNotify.getNonce());
}
public void handleMapRegisterIpv6__ValidMask48() throws Exception {
int mask = 48;
mapRegisterBuilder = getDefaultMapRegisterBuilder();
- LispAddressContainer addr = LispAFIConvertor.asIPv6Prefix(eidIpv6String, mask);
- EidToLocatorRecordBuilder recordBuilder = getDefaultEidToLocatorBuilder();
+ Eid addr = LispAddressUtil.asIpv6PrefixEid(eidIpv6String +"/" + mask);
+ MappingRecordBuilder recordBuilder = getDefaultMappingRecordBuilder();
LocatorRecordBuilder locatorBuilder = getDefaultLocatorBuilder();
- locatorBuilder.setLispAddressContainer(rloc);
- recordBuilder.setLispAddressContainer(addr).setMaskLength((short) mask);
+ locatorBuilder.setRloc(rloc);
+ recordBuilder.setEid(addr).setMaskLength((short) mask);
recordBuilder.getLocatorRecord().add(locatorBuilder.build());
- mapRegisterBuilder.getEidToLocatorRecord().add(recordBuilder.build());
+ mapRegisterBuilder.getMappingRecordItem().add(new MappingRecordItemBuilder().setMappingRecord(recordBuilder.build()).build());
mapRegisterBuilder.setWantMapNotify(true);
addDefaultPutAndGetExpectations(addr);
MapRegister mapRegister = mapRegisterBuilder.build();
MapNotify mapNotify = testedMapServer.handleMapRegister(mapRegister);
- assertEquals(addr, mapNotify.getEidToLocatorRecord().get(0).getLispAddressContainer());
+ assertEquals(addr, mapNotify.getMappingRecordItem().get(0).getMappingRecord().getEid());
ArrayAssert.assertEquals(mapRegister.getAuthenticationData(), mapNotify.getAuthenticationData());
- assertEquals(mapRegister.getEidToLocatorRecord(), mapNotify.getEidToLocatorRecord());
+ assertEquals(mapRegister.getMappingRecordItem(), mapNotify.getMappingRecordItem());
assertEquals(mapRegister.getKeyId(), mapNotify.getKeyId());
assertEquals(mapRegister.getNonce(), mapNotify.getNonce());
}
public void handleMapRegisterIpv6__ValidMask128() throws Exception {
int mask = 128;
mapRegisterBuilder = getDefaultMapRegisterBuilder();
- LispAddressContainer addr = LispAFIConvertor.asIPv6Address(eidIpv6String);
- EidToLocatorRecordBuilder recordBuilder = getDefaultEidToLocatorBuilder();
+ Eid addr = LispAddressUtil.asIpv6PrefixEid(eidIpv6String);
+ MappingRecordBuilder recordBuilder = getDefaultMappingRecordBuilder();
LocatorRecordBuilder locatorBuilder = getDefaultLocatorBuilder();
- locatorBuilder.setLispAddressContainer(rloc);
- recordBuilder.setLispAddressContainer(addr).setMaskLength((short) mask);
+ locatorBuilder.setRloc(rloc);
+ recordBuilder.setEid(addr).setMaskLength((short) mask);
recordBuilder.getLocatorRecord().add(locatorBuilder.build());
- mapRegisterBuilder.getEidToLocatorRecord().add(recordBuilder.build());
+ mapRegisterBuilder.getMappingRecordItem().add(new MappingRecordItemBuilder().setMappingRecord(recordBuilder.build()).build());
mapRegisterBuilder.setWantMapNotify(true);
addDefaultPutAndGetExpectations(addr);
MapRegister mapRegister = mapRegisterBuilder.build();
MapNotify mapNotify = testedMapServer.handleMapRegister(mapRegister);
- assertEquals(addr, mapNotify.getEidToLocatorRecord().get(0).getLispAddressContainer());
+ assertEquals(addr, mapNotify.getMappingRecordItem().get(0).getMappingRecord().getEid());
ArrayAssert.assertEquals(mapRegister.getAuthenticationData(), mapNotify.getAuthenticationData());
- assertEquals(mapRegister.getEidToLocatorRecord(), mapNotify.getEidToLocatorRecord());
+ assertEquals(mapRegister.getMappingRecordItem(), mapNotify.getMappingRecordItem());
assertEquals(mapRegister.getKeyId(), mapNotify.getKeyId());
assertEquals(mapRegister.getNonce(), mapNotify.getNonce());
}
public void handleMapRegisterIPV4AndIpv6__ValidMask96() throws Exception {
int mask = 96;
mapRegisterBuilder = getDefaultMapRegisterBuilder();
- EidToLocatorRecordBuilder recordBuilder0 = getDefaultEidToLocatorBuilder();
- recordBuilder0.setLispAddressContainer(eid).setMaskLength((short) 32);
- LispAddressContainer addr = LispAFIConvertor.asIPv6Prefix(eidIpv6String, mask);
- EidToLocatorRecordBuilder recordBuilder1 = getDefaultEidToLocatorBuilder();
+ MappingRecordBuilder recordBuilder0 = getDefaultMappingRecordBuilder();
+ recordBuilder0.setEid(eid).setMaskLength((short) 32);
+ Eid addr = LispAddressUtil.asIpv6PrefixEid(eidIpv6String + "/" + mask);
+ MappingRecordBuilder recordBuilder1 = getDefaultMappingRecordBuilder();
LocatorRecordBuilder locatorBuilder = getDefaultLocatorBuilder();
- locatorBuilder.setLispAddressContainer(rloc);
- locatorBuilder.setLispAddressContainer(rloc);
- recordBuilder1.setLispAddressContainer(addr).setMaskLength((short) mask);
+ locatorBuilder.setRloc(rloc);
+ locatorBuilder.setRloc(rloc);
+ recordBuilder1.setEid(addr).setMaskLength((short) mask);
recordBuilder1.getLocatorRecord().add(locatorBuilder.build());
- mapRegisterBuilder.getEidToLocatorRecord().add(recordBuilder0.build());
- mapRegisterBuilder.getEidToLocatorRecord().add(recordBuilder1.build());
+ mapRegisterBuilder.getMappingRecordItem().add(new MappingRecordItemBuilder().setMappingRecord(recordBuilder0.build()).build());
+ mapRegisterBuilder.getMappingRecordItem().add(new MappingRecordItemBuilder().setMappingRecord(recordBuilder1.build()).build());
mapRegisterBuilder.setWantMapNotify(true);
addDefaultPutAndGetExpectations(eid);
MapRegister mapRegister = mapRegisterBuilder.build();
MapNotify mapNotify = testedMapServer.handleMapRegister(mapRegister);
- assertEquals(eid, mapNotify.getEidToLocatorRecord().get(0).getLispAddressContainer());
- assertEquals(addr, mapNotify.getEidToLocatorRecord().get(1).getLispAddressContainer());
+ assertEquals(eid, mapNotify.getMappingRecordItem().get(0).getMappingRecord().getEid());
+ assertEquals(addr, mapNotify.getMappingRecordItem().get(1).getMappingRecord().getEid());
ArrayAssert.assertEquals(mapRegister.getAuthenticationData(), mapNotify.getAuthenticationData());
- assertEquals(mapRegister.getEidToLocatorRecord(), mapNotify.getEidToLocatorRecord());
+ assertEquals(mapRegister.getMappingRecordItem(), mapNotify.getMappingRecordItem());
assertEquals(mapRegister.getKeyId(), mapNotify.getKeyId());
assertEquals(mapRegister.getNonce(), mapNotify.getNonce());
}
addDefaultPutAndGetExpectations(eid);
mapRegisterBuilder = getDefaultMapRegisterBuilder();
- LispAddressContainer rloc0 = rloc;
- LispAddressContainer rloc1 = LispAFIConvertor.asIPv6Address("0:0:0:0:0:0:0:7");
- EidToLocatorRecordBuilder recordBuilder = getDefaultEidToLocatorBuilder();
- recordBuilder.setLispAddressContainer(eid);
+ Rloc rloc0 = rloc;
+ Rloc rloc1 = LispAddressUtil.asIpv6Rloc("0:0:0:0:0:0:0:7");
+ MappingRecordBuilder recordBuilder = getDefaultMappingRecordBuilder();
+ recordBuilder.setEid(eid);
LocatorRecordBuilder locatorBuilder1 = getDefaultLocatorBuilder();
- locatorBuilder1.setLispAddressContainer(rloc0);
+ locatorBuilder1.setRloc(rloc0);
LocatorRecordBuilder locatorBuilder2 = getDefaultLocatorBuilder();
- locatorBuilder2.setLispAddressContainer(rloc1);
+ locatorBuilder2.setRloc(rloc1);
recordBuilder.getLocatorRecord().add(locatorBuilder1.build());
recordBuilder.getLocatorRecord().add(locatorBuilder2.build());
- mapRegisterBuilder.getEidToLocatorRecord().add(recordBuilder.build());
+ mapRegisterBuilder.getMappingRecordItem().add(new MappingRecordItemBuilder().setMappingRecord(recordBuilder.build()).build());
testedMapServer.handleMapRegister(mapRegisterBuilder.build());
assertEquals(1, entries.length);
assertEquals(SubKeys.RECORD, entries[0].getKey());
- assertEquals(rloc0, ((EidToLocatorRecord) entries[0].getValue()).getLocatorRecord()
- .get(0).getLispAddressContainer());
- assertEquals(rloc1, ((EidToLocatorRecord) entries[0].getValue()).getLocatorRecord()
- .get(1).getLispAddressContainer());
+ assertEquals(rloc0, ((MappingRecord) entries[0].getValue()).getLocatorRecord()
+ .get(0).getRloc());
+ assertEquals(rloc1, ((MappingRecord) entries[0].getValue()).getLocatorRecord()
+ .get(1).getRloc());
}
addDefaultPutAndGetExpectations(eid);
mapRegisterBuilder = getDefaultMapRegisterBuilder();
- LispAddressContainer rloc0 = rloc;
+ Rloc rloc0 = rloc;
// LispAFIAddress rloc1 =
- // LispAFIConvertor.asIPv6AfiAddress("0:0:0:0:0:0:0:7");
+ // LispAddressUtil.asIPv6AfiAddress("0:0:0:0:0:0:0:7");
String subkey = "bla";
- LispAFIAddress rloc1 = LispAFIConvertor
- .asKeyValue(subkey, LispAFIConvertor.toPrimitive(LispAFIConvertor.asIPv6AfiAddress("0:0:0:0:0:0:0:7")));
- EidToLocatorRecordBuilder recordBuilder = getDefaultEidToLocatorBuilder();
- recordBuilder.setLispAddressContainer(eid);
+ Rloc rloc1 = LispAddressUtil.asKeyValueAddress(subkey, SimpleAddressBuilder.getDefaultInstance("0:0:0:0:0:0:0:7"));
+ MappingRecordBuilder recordBuilder = getDefaultMappingRecordBuilder();
+ recordBuilder.setEid(eid);
LocatorRecordBuilder locatorBuilder1 = getDefaultLocatorBuilder();
- locatorBuilder1.setLispAddressContainer(rloc0);
+ locatorBuilder1.setRloc(rloc0);
LocatorRecordBuilder locatorBuilder2 = getDefaultLocatorBuilder();
- locatorBuilder2.setLispAddressContainer(LispAFIConvertor.toContainer(rloc1));
+ locatorBuilder2.setRloc(rloc1);
recordBuilder.getLocatorRecord().add(locatorBuilder1.build());
recordBuilder.getLocatorRecord().add(locatorBuilder2.build());
- mapRegisterBuilder.getEidToLocatorRecord().add(recordBuilder.build());
+ mapRegisterBuilder.getMappingRecordItem().add(new MappingRecordItemBuilder().setMappingRecord(recordBuilder.build()).build());
testedMapServer.handleMapRegister(mapRegisterBuilder.build());
MappingEntry<?>[] entries = mappingEntriesSaver.lastValue;
assertEquals(1, entries.length);
- EidToLocatorRecord storedMapping = (EidToLocatorRecord) entries[0].getValue();
+ MappingRecord storedMapping = (MappingRecord) entries[0].getValue();
assertEquals(2, storedMapping.getLocatorRecord().size());
assertEquals(SubKeys.RECORD, entries[0].getKey());
- assertEquals(rloc0, storedMapping.getLocatorRecord().get(0).getLispAddressContainer());
- assertEquals(LispAFIConvertor.toContainer(rloc1), storedMapping.getLocatorRecord().get(1)
- .getLispAddressContainer());
+ assertEquals(rloc0, storedMapping.getLocatorRecord().get(0).getRloc());
+ assertEquals(rloc1, storedMapping.getLocatorRecord().get(1).getRloc());
}
assertEquals(1, entries.length);
assertEquals(SubKeys.RECORD, entries[0].getKey());
- assertEquals(rloc, ((EidToLocatorRecord) entries[0].getValue()).getLocatorRecord()
- .get(0).getLispAddressContainer());
+ assertEquals(rloc, ((MappingRecord) entries[0].getValue()).getLocatorRecord().get(0).getRloc());
}
// @Test
//
// assertEquals(String.valueOf(hc), entries[0].getKey());
// assertEquals(rloc, ((EidToLocatorRecord) entries[0].getValue()).getLocatorRecord()
-// .get(0).getLispAddressContainer());
+// .get(0).getEid());
// }
private void addEidToLocatorRecord() {
- EidToLocatorRecordBuilder recordBuilder = getDefaultEidToLocatorBuilder();
- recordBuilder.setLispAddressContainer(eid);
+ MappingRecordBuilder recordBuilder = getDefaultMappingRecordBuilder();
+ recordBuilder.setEid(eid);
LocatorRecordBuilder locatorBuilder = getDefaultLocatorBuilder();
- locatorBuilder.setLispAddressContainer(rloc);
+ locatorBuilder.setRloc(rloc);
recordBuilder.getLocatorRecord().add(locatorBuilder.build());
mapRegisterBuilder = getDefaultMapRegisterBuilder();
- mapRegisterBuilder.getEidToLocatorRecord().add(recordBuilder.build());
+ mapRegisterBuilder.getMappingRecordItem().add(new MappingRecordItemBuilder().setMappingRecord(recordBuilder.build()).build());
testedMapServer.handleMapRegister(mapRegisterBuilder.build());
}
public void handleMapRegister__MultipleEIDs() throws Exception {
addDefaultPutAndGetExpectations(eid);
- LispAddressContainer rloc1 = LispAFIConvertor.asIPv6Address("0:0:0:0:0:0:0:7");
+ Rloc rloc1 = LispAddressUtil.asIpv6Rloc("0:0:0:0:0:0:0:7");
mapRegisterBuilder = getDefaultMapRegisterBuilder();
- EidToLocatorRecordBuilder etlrBuilder = getDefaultEidToLocatorBuilder();
- etlrBuilder.getLocatorRecord().add(getDefaultLocatorBuilder().setLispAddressContainer(rloc1).build());
+ MappingRecordBuilder etlrBuilder = getDefaultMappingRecordBuilder();
+ etlrBuilder.getLocatorRecord().add(getDefaultLocatorBuilder().setRloc(rloc1).build());
mapRegisterBuilder.setWantMapNotify(true);
- etlrBuilder.setLispAddressContainer(eid);
+ etlrBuilder.setEid(eid);
- EidToLocatorRecordBuilder etlr2Builder = getDefaultEidToLocatorBuilder();
- LispAddressContainer address = LispAFIConvertor.asIPv4Address("1.1.1.1");
- etlr2Builder.setLispAddressContainer(address);
+ MappingRecordBuilder etlr2Builder = getDefaultMappingRecordBuilder();
+ Eid address = LispAddressUtil.asIpv4PrefixEid("1.1.1.1");
+ etlr2Builder.setEid(address);
etlr2Builder.setMaskLength((short) 32);
int recordTtl = 5;
etlr2Builder.setRecordTtl(recordTtl);
etlr2Builder.getLocatorRecord().add(
getDefaultLocatorBuilder().setPriority((short) 10)
- .setLispAddressContainer(LispAFIConvertor.toContainer(LispAFIConvertor.asIPAfiAddress("2.2.2.2"))).build());
- mapRegisterBuilder.getEidToLocatorRecord().add(etlrBuilder.build());
- mapRegisterBuilder.getEidToLocatorRecord().add(etlr2Builder.build());
+ .setRloc(LispAddressUtil.asIpv4Rloc("2.2.2.2")).build());
+ mapRegisterBuilder.getMappingRecordItem().add(new MappingRecordItemBuilder().setMappingRecord(etlrBuilder.build()).build());
+ mapRegisterBuilder.getMappingRecordItem().add(new MappingRecordItemBuilder().setMappingRecord(etlr2Builder.build()).build());
addDefaultPutAndGetExpectations(address);
MapNotify mapNotify = testedMapServer.handleMapRegister(mapRegisterBuilder.build());
- assertEquals(rloc1, mapNotify.getEidToLocatorRecord().get(0).getLocatorRecord().get(0)
- .getLispAddressContainer());
- assertEquals(LispAFIConvertor.toContainer(LispAFIConvertor.asIPAfiAddress("2.2.2.2")), mapNotify.getEidToLocatorRecord().get(1)
- .getLocatorRecord().get(0).getLispAddressContainer());
- assertEquals(address, mapNotify.getEidToLocatorRecord().get(1).getLispAddressContainer());
- assertEquals(recordTtl, mapNotify.getEidToLocatorRecord().get(1).getRecordTtl().intValue());
+ assertEquals(rloc1, mapNotify.getMappingRecordItem().get(0).getMappingRecord().getLocatorRecord().get(0)
+ .getRloc());
+ assertEquals(LispAddressUtil.asIpv4Rloc("2.2.2.2"), mapNotify.getMappingRecordItem().get(1).getMappingRecord()
+ .getLocatorRecord().get(0).getRloc());
+ assertEquals(address, mapNotify.getMappingRecordItem().get(1).getMappingRecord().getEid());
+ assertEquals(recordTtl, mapNotify.getMappingRecordItem().get(1).getMappingRecord().getRecordTtl().intValue());
}
@Test
public void handleMapRegisterIpv4__CheckWrongPassword() throws Exception {
- addGetExpectations(LispAFIConvertor.asIPv4Address("153.16.254.1"), 0, 31, "bla");
+ addGetExpectations(LispAddressUtil.asIpv4PrefixEid("153.16.254.1"), 0, 31, "bla");
MapNotify mapNotify = testedMapServer.handleMapRegister(mapRegisterWithAuthentication);
assertEquals(null, mapNotify);
}
@Test
public void handleMapRegisterIpv4__CheckNoPasswordAndThenPassword() throws Exception {
- addGetExpectations(LispAFIConvertor.asIPv4Address("153.16.254.1"), 0, 25, "password");
- addPutExpectations(LispAFIConvertor.asIPv4Address("153.16.254.1"));
+ addGetExpectations(LispAddressUtil.asIpv4PrefixEid("153.16.254.1"), 0, 25, "password");
+ addPutExpectations(LispAddressUtil.asIpv4PrefixEid("153.16.254.1"));
MapNotify mapNotify = testedMapServer.handleMapRegister(mapRegisterWithAuthentication);
- assertEquals(mapRegisterWithAuthentication.getEidToLocatorRecord(), mapNotify.getEidToLocatorRecord());
+ assertEquals(mapRegisterWithAuthentication.getMappingRecordItem(), mapNotify.getMappingRecordItem());
assertEquals(mapRegisterWithAuthentication.getKeyId(), mapNotify.getKeyId());
assertEquals(mapRegisterWithAuthentication.getNonce(), mapNotify.getNonce());
}
@Test
public void handleMapRegisterIpv4__CheckNoPassword() throws Exception {
- addGetExpectations(LispAFIConvertor.asIPv4Address("153.16.254.1"), 30, 0, "password");
+ addGetExpectations(LispAddressUtil.asIpv4PrefixEid("153.16.254.1/32"), 30, 0, "password");
MapNotify mapNotify = testedMapServer.handleMapRegister(mapRegisterWithAuthentication);
assertEquals(null, mapNotify);
}
@Test
public void handleMapRegisterIpv4__CheckNoreturn() throws Exception {
- addGetExpectations(LispAFIConvertor.asIPv4Address("153.16.254.1"));
+ addGetExpectations(LispAddressUtil.asIpv4PrefixEid("153.16.254.1/32"));
MapNotify mapNotify = testedMapServer.handleMapRegister(mapRegisterWithAuthentication);
assertEquals(mapNotify, null);
}
- private void addDefaultPutAndGetExpectations(LispAddressContainer addr) {
+ private void addDefaultPutAndGetExpectations(Eid addr) {
addPutExpectations(addr);
addGetExpectations(addr);
}
- private void addGetExpectations(LispAddressContainer address) {
- addGetExpectations(address, 0, 0, SubKeys.AUTH_KEY);
- }
-
- private EidToLocatorRecord toEidToLocatorRecord(Mapping record) {
- return new EidToLocatorRecordBuilder(
- (org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.EidToLocatorRecord) record)
- .build();
+ private void addGetExpectations(Eid address) {
+ addGetExpectations(address, 0, 0, SubKeys.AUTH_KEY);
}
private void prepareDsbe() {
ValueSaverAction<Mapping> dsbeAddMappingSaverAction = new ValueSaverAction<Mapping>() {
@Override
public Object invoke(Invocation invocation) throws Throwable {
- mapSystem.addMapping(lastValue.getOrigin(), lastValue.getLispAddressContainer(), (Object) toEidToLocatorRecord(lastValue));
+ mapSystem.addMapping(lastValue.getOrigin(), lastValue.getMappingRecord().getEid(),
+ (Object) lastValue.getMappingRecord());
return null;
}
};
oneOf(dsbe).addMapping(with(dsbeAddMappingSaverAction)); will(dsbeAddMappingSaverAction);
}
- private void addPutExpectations(LispAddressContainer address) {
+ private void addPutExpectations(Eid address) {
// needed for mapping-service addMapping
prepareDsbe();
exactly(2).of(dao).put(weq(address), with(mappingEntriesSaver));
}
- private void addGetExpectations(LispAddressContainer address, int withoutPassword, int withPassword, String password) {
+ private void addGetExpectations(Eid address, int withoutPassword, int withPassword, String password) {
if (withoutPassword > 0) {
String result = null;
result = null;
allowing(dao).getSpecific(with(address), with(SubKeys.AUTH_KEY));
ret(result);
}
- for (int i = MaskUtil.getMaskForAddress(address); i >= 0; i--) {
- LispAddressContainer addr = MaskUtil.normalize(address, (short) i);
+ for (int i = MaskUtil.getMaskForAddress(address.getAddress()); i >= 0; i--) {
+ Eid addr = MaskUtil.normalize(address, (short) i);
allowing(dao).getSpecific(with(addr), with(SubKeys.AUTH_KEY)); ret(null);
// check if mapping exists before insertion
allowing(dao).get(with(addr));will(returnValue(null));
}
- private LispAddressContainer getDefaultKey() {
- return getKey(32);
- }
-
- private LispAddressContainer getKey(int mask) {
- return MaskUtil.normalize(eid, (short)mask);
- }
-
private MapRegisterBuilder getDefaultMapRegisterBuilder() {
MapRegisterBuilder mrb = new MapRegisterBuilder();
mrb.setKeyId((short) 0);
mrb.setNonce((long) 0);
mrb.setWantMapNotify(false);
mrb.setProxyMapReply(false);
- mrb.setEidToLocatorRecord(new ArrayList<EidToLocatorRecord>());
+ mrb.setMappingRecordItem(new ArrayList<MappingRecordItem>());
mrb.setAuthenticationData(new byte[0]);
return mrb;
}
- private EidToLocatorRecordBuilder getDefaultEidToLocatorBuilder() {
- EidToLocatorRecordBuilder builder = new EidToLocatorRecordBuilder();
+ private MappingRecordBuilder getDefaultMappingRecordBuilder() {
+ MappingRecordBuilder builder = new MappingRecordBuilder();
builder.setAction(Action.NoAction);
builder.setAuthoritative(false);
builder.setLocatorRecord(new ArrayList<LocatorRecord>());
import org.opendaylight.lispflowmapping.interfaces.dao.ILispDAO;
import org.opendaylight.lispflowmapping.interfaces.dao.MappingEntry;
import org.opendaylight.lispflowmapping.interfaces.dao.SubKeys;
-import org.opendaylight.lispflowmapping.lisp.util.LispAFIConvertor;
+import org.opendaylight.lispflowmapping.lisp.util.LispAddressUtil;
import org.opendaylight.lispflowmapping.lisp.util.MaskUtil;
import org.opendaylight.lispflowmapping.tools.junit.BaseTestCase;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.lispaddress.LispAddressContainer;
+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.MappingOrigin;
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.mapping.authkey.container.MappingAuthkey;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.mappingservice.rev150906.mapping.authkey.container.MappingAuthkeyBuilder;
/**
*
private DataStoreBackEnd dsbe;
private MappingSystem mapSystem;
- private LispAddressContainer eid;
+ private Eid eid;
private String eidIpv4String = "10.31.0.5";
@Override
inject(mapService, "dsbe", dsbe);
inject(mapService, "mappingSystem", mapSystem);
- eid = LispAFIConvertor.asIPv4Address(eidIpv4String);
+ eid = LispAddressUtil.asIpv4PrefixEid(eidIpv4String + "/32");
}
@SuppressWarnings("unchecked")
@Test
public void handleAddAuthenticationKey() throws Exception {
- String authKey = "pass";
- MappingEntry<String> keyMappingEntry = new MappingEntry<String>(SubKeys.AUTH_KEY, authKey);
- LispAddressContainer key = getDefaultKey();
- MappingEntry<String>[] authKeys =(MappingEntry<String>[]) (Arrays.asList(keyMappingEntry).toArray());
+ MappingAuthkey authKey = new MappingAuthkeyBuilder().setKeyType(1).setKeyString("pass").build();
+ MappingEntry<MappingAuthkey> keyMappingEntry = new MappingEntry<>(SubKeys.AUTH_KEY, authKey);
+ Eid key = getDefaultKey();
+ MappingEntry<MappingAuthkey>[] authKeys =(MappingEntry<MappingAuthkey>[]) (Arrays.asList(keyMappingEntry).toArray());
addDsbeAddKeyExpectation();
oneOf(dao).put(weq(key), weq(authKeys));
mapService.addAuthenticationKey(eid, authKey);
@Test
public void handleGetAuthenticationKey() throws Exception {
- LispAddressContainer key = getDefaultKey();
+ Eid key = getDefaultKey();
oneOf(dao).getSpecific(weq(key), with(SubKeys.AUTH_KEY));
ret("password");
assertEquals("password", mapService.getAuthenticationKey(eid));
@Test
public void handleGetAuthenticationKeyNoIteration() throws Exception {
mapSystem.setIterateMask(false);
- LispAddressContainer key = getDefaultKey();
- LispAddressContainer passKey = getKey(30);
+ Eid key = getDefaultKey();
+ Eid passKey = getKey(30);
oneOf(dao).getSpecific(weq(key), with(SubKeys.AUTH_KEY));
allowing(dao).getSpecific(weq(passKey), with(SubKeys.AUTH_KEY));
ret("password");
@Test
public void handleRemoveAuthenticationKey() throws Exception {
- LispAddressContainer key = getDefaultKey();
+ Eid key = getDefaultKey();
addDsbeRemoveKeyExpectation();
oneOf(dao).removeSpecific(weq(key), with(SubKeys.AUTH_KEY));
mapService.removeAuthenticationKey(eid);
}
- private LispAddressContainer getDefaultKey() {
+ private Eid getDefaultKey() {
return getKey(32);
}
- private LispAddressContainer getKey(int mask) {
- return MaskUtil.normalize(eid, (short)mask);
+ private Eid getKey(int mask) {
+ Eid key = LispAddressUtil.asIpv4PrefixEid(eidIpv4String + "/" + Integer.toString(mask));
+ return MaskUtil.normalize(key, (short) mask);
}
private void addDsbeAddKeyExpectation() {
ValueSaverAction<AuthenticationKey> dsbeAddKeySaverAction = new ValueSaverAction<AuthenticationKey>() {
@Override
public Object invoke(Invocation invocation) throws Throwable {
- mapSystem.addAuthenticationKey(lastValue.getLispAddressContainer(), lastValue.getAuthkey());
+ mapSystem.addAuthenticationKey(lastValue.getEid(), lastValue.getMappingAuthkey());
return null;
}
};
ValueSaverAction<AuthenticationKey> dsbeRemoveKeySaverAction = new ValueSaverAction<AuthenticationKey>() {
@Override
public Object invoke(Invocation invocation) throws Throwable {
- mapSystem.removeAuthenticationKey(lastValue.getLispAddressContainer());
+ mapSystem.removeAuthenticationKey(lastValue.getEid());
return null;
}
};
import java.net.Inet4Address;
import java.net.Inet6Address;
import java.net.InetAddress;
+import java.util.ArrayList;
+import java.util.List;
import java.util.regex.Pattern;
import java.util.regex.PatternSyntaxException;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.lisp.address.types.rev151105.AsNumberAfi;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.lisp.address.types.rev151105.DistinguishedNameAfi;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.lisp.address.types.rev151105.DistinguishedNameType;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.lisp.address.types.rev151105.ExplicitLocatorPathLcaf;
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.ietf.params.xml.ns.yang.ietf.lisp.address.types.rev151105.Ipv4Afi;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.lisp.address.types.rev151105.Ipv4PrefixAfi;
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.SourceDestKeyLcaf;
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.DistinguishedNameBuilder;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.lisp.address.types.rev151105.lisp.address.address.Ipv4Builder;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.lisp.address.types.rev151105.lisp.address.address.Ipv4PrefixBuilder;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.lisp.address.types.rev151105.lisp.address.address.Ipv6Builder;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.lisp.address.types.rev151105.lisp.address.address.MacBuilder;
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.eid.container.EidBuilder;
+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;
import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.rloc.container.Rloc;
import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.rloc.container.RlocBuilder;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.lisp.address.types.rev151105.lisp.address.address.key.value.address.KeyValueAddressBuilder;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.lisp.address.types.rev151105.lisp.address.address.source.dest.key.SourceDestKey;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.lisp.address.types.rev151105.lisp.address.address.source.dest.key.SourceDestKeyBuilder;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.yang.types.rev100924.MacAddress;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.lisp.address.types.rev151105.lisp.address.address.explicit.locator.path.ExplicitLocatorPathBuilder;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.lisp.address.types.rev151105.lisp.address.address.explicit.locator.path.explicit.locator.path.Hop;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.lisp.address.types.rev151105.lisp.address.address.explicit.locator.path.explicit.locator.path.Hop.LrsBits;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.lisp.address.types.rev151105.lisp.address.address.explicit.locator.path.explicit.locator.path.HopBuilder;
public class LispAddressUtil {
private static Pattern IP4_PATTERN = null;
EidBuilder builder = new EidBuilder();
builder.setAddress(addressFromIpPrefix(prefix));
builder.setAddressType(addressTypeFromIpPrefix(prefix));
- builder.setVirtualNetworkId(new InstanceIdType(Long.valueOf(vni)));
+ // XXX getMapping rcp fails if set to 0
+ //builder.setVirtualNetworkId(new InstanceIdType(Long.valueOf(vni)));
return builder.build();
}
+ public static Eid toIpPrefixEid(IpAddress addr, int vni) {
+ int mask = addressTypeFromIpAddress(addr) == Ipv4Afi.class ? 32 : 128;
+ IpPrefix prefix = asIpPrefix(addr.getValue().toString(), mask);
+ return toEid(prefix, vni);
+ }
+
public static Eid asIpv4PrefixEid(String prefix) {
return toEid(new Ipv4Prefix(prefix), null);
}
return toEid(new MacAddress(address), null);
}
+ public static Eid toEid(DistinguishedNameType dn, InstanceIdType vni) {
+ EidBuilder builder = new EidBuilder();
+ builder.setAddressType(DistinguishedNameAfi.class);
+ builder.setVirtualNetworkId(vni);
+ builder.setAddress((Address) new DistinguishedNameBuilder().setDistinguishedName(dn).build());
+ return builder.build();
+ }
+
+ public static Eid asDistinguishedNameEid(String address, long vni) {
+ return toEid(new MacAddress(address), new InstanceIdType(vni));
+ }
+
+ public static Eid asDistinguishedNameEid(String address) {
+ return toEid(new DistinguishedNameType(address), null);
+ }
+
public static Rloc asKeyValueAddress(String key, SimpleAddress value) {
KeyValueAddressBuilder kvab = new KeyValueAddressBuilder();
kvab.setKey(new SimpleAddress(new DistinguishedNameType(key)));
.setSourceDestKey(sd).build());
return builder.build();
}
+
+ public static Rloc asTeLcafRloc(List<IpAddress> hopList) {
+ RlocBuilder teBuilder = new RlocBuilder();
+ org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.lisp.address.types.rev151105.lisp.address.address.ExplicitLocatorPathBuilder elpBuilder =
+ new org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.lisp.address.types.rev151105.lisp.address.address.ExplicitLocatorPathBuilder();
+ ExplicitLocatorPathBuilder teAddrBuilder = new ExplicitLocatorPathBuilder();
+ teAddrBuilder.setHop(new ArrayList<Hop>());
+ for (IpAddress hop : hopList) {
+ HopBuilder hopBuilder = new HopBuilder();
+ hopBuilder.setAddress(new SimpleAddress(hop));
+ hopBuilder.setHopId("Hop " + teAddrBuilder.getHop().size());
+ hopBuilder.setLrsBits(new LrsBits(false, false, false));
+ teAddrBuilder.getHop().add(hopBuilder.build());
+ }
+
+ elpBuilder.setExplicitLocatorPath(teAddrBuilder.build());
+ teBuilder.setAddress(elpBuilder.build());
+ teBuilder.setAddressType(ExplicitLocatorPathLcaf.class);
+ return teBuilder.build();
+ }
+
+ public static List<LocatorRecord> asLocatorRecords(List<Rloc> locators) {
+ List<LocatorRecord> locatorRecords = new ArrayList<LocatorRecord>();
+ for (Rloc locator : locators) {
+ LocatorRecordBuilder locatorBuilder = new LocatorRecordBuilder();
+ locatorBuilder.setLocalLocator(false).setRlocProbed(false).setWeight((short) 1).setPriority((short) 1)
+ .setMulticastWeight((short) 1).setMulticastPriority((short) 1).setRouted(true)
+ .setRloc(locator).setLocatorId("SFC_LISP").build();
+ locatorRecords.add(locatorBuilder.build());
+ }
+ return locatorRecords;
+ }
}
package org.opendaylight.lispflowmapping.neutron;
import org.opendaylight.lispflowmapping.interfaces.lisp.IFlowMapping;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.mappingservice.rev150906.MappingserviceService;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.mappingservice.rev150906.OdlMappingserviceService;
public interface ILispNeutronService {
public IFlowMapping getMappingService();
- public MappingserviceService getMappingDbService();
+ public OdlMappingserviceService getMappingDbService();
}
import java.util.concurrent.Future;
import org.apache.commons.lang3.exception.ExceptionUtils;
-import org.opendaylight.lispflowmapping.lisp.util.LispAFIConvertor;
+import org.opendaylight.lispflowmapping.lisp.util.LispAddressUtil;
import org.opendaylight.neutron.spi.INeutronPortAware;
import org.opendaylight.neutron.spi.NeutronPort;
import org.opendaylight.neutron.spi.Neutron_IPs;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.LispAFIAddress;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.eidtolocatorrecords.EidToLocatorRecord;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.lispaddress.LispAddressContainer;
+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.mapping.record.container.MappingRecord;
import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.mappingservice.rev150906.GetMappingInput;
import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.mappingservice.rev150906.GetMappingOutput;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.mappingservice.rev150906.MappingserviceService;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.mappingservice.rev150906.OdlMappingserviceService;
import org.opendaylight.yangtools.yang.common.RpcResult;
/**
+ port.toString());
return;
}
- LispAFIAddress hostAddress = LispAFIConvertor.asDistinguishedNameAddress(port.getBindinghostID());
+ Eid hostAddress = LispAddressUtil.asDistinguishedNameEid(port.getBindinghostID());
- EidToLocatorRecord eidRecord;
+ MappingRecord eidRecord;
List<LocatorRecord> hostLocRecords;
- GetMappingInput input = LispUtil.buildGetMappingInput(LispAFIConvertor.toContainer(hostAddress), (short) 0);
+ GetMappingInput input = LispUtil.buildGetMappingInput(hostAddress);
try {
- MappingserviceService lfmdb = lispNeutronService.getMappingDbService();
+ OdlMappingserviceService lfmdb = lispNeutronService.getMappingDbService();
if (lfmdb == null) {
LOG.debug("lfmdb is null!!!");
return;
// TODO for now only selecting the first EidToLocatorRecord from the
// Host_ID mapping
- eidRecord = output.getEidToLocatorRecord().get(0);
+ eidRecord = output.getMappingRecord();
hostLocRecords = eidRecord.getLocatorRecord();
LOG.debug("hostLocRecords is : {}",hostLocRecords);
List<Neutron_IPs> fixedIPs = port.getFixedIPs();
if (fixedIPs != null && fixedIPs.size() > 0) {
- LispAddressContainer eidAddress;
+ Eid eidAddress;
for (Neutron_IPs ip : fixedIPs) {
// TODO Add check/support for IPv6.
// Get subnet for this port, based on v4 or v6 decide address
// iana code.
- eidAddress = LispAFIConvertor.toContainer(LispAFIConvertor.asIPAfiAddress(ip.getIpAddress()));
- lispNeutronService.getMappingDbService().addMapping(LispUtil.buildAddMappingInput(eidAddress, hostLocRecords, 32));
+ eidAddress = LispAddressUtil.asIpv4PrefixEid(ip.getIpAddress() + "/32");
+ lispNeutronService.getMappingDbService().addMapping(LispUtil.buildAddMappingInput(eidAddress, hostLocRecords));
}
}
List<Neutron_IPs> fixedIPs = port.getFixedIPs();
if (fixedIPs != null && fixedIPs.size() > 0) {
- LispAddressContainer eidAddress;
+ Eid eidAddress;
for (Neutron_IPs ip : fixedIPs) {
// Get subnet for this port, based on v4 or v6 decide address
// iana code.
- eidAddress = LispAFIConvertor.toContainer(LispAFIConvertor.asIPAfiAddress(ip.getIpAddress()));
- lispNeutronService.getMappingDbService().removeMapping(LispUtil.buildRemoveMappingInput(eidAddress,32));
+ eidAddress = LispAddressUtil.asIpv4PrefixEid(ip.getIpAddress() + "/32");
+ lispNeutronService.getMappingDbService().removeMapping(LispUtil.buildRemoveMappingInput(eidAddress));
LOG.info("Neutron Port mapping deleted from lisp: "
+ " Port Fixed IP: " + ip + "Port host IP: ");
import org.opendaylight.controller.sal.binding.api.RpcProviderRegistry;
import org.opendaylight.controller.sal.binding.api.BindingAwareBroker.ProviderContext;
import org.opendaylight.lispflowmapping.interfaces.lisp.IFlowMapping;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.mappingservice.rev150906.MappingserviceService;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.mappingservice.rev150906.OdlMappingserviceService;
public class LispNeutronService implements ILispNeutronService, BindingAwareProvider {
protected static final Logger LOG = LoggerFactory.getLogger(LispNeutronService.class);
private IFlowMapping mappingService;
- private MappingserviceService lfmDbService;
+ private OdlMappingserviceService lfmDbService;
private static ILispNeutronService neutronService;
return this.mappingService;
}
- public MappingserviceService getMappingDbService() {
+ public OdlMappingserviceService getMappingDbService() {
return this.lfmDbService;
}
public void onSessionInitiated(ProviderContext session) {
LOG.debug("LFMDBSERVICE IS BEING FILLED! SESSION INITIATED");
RpcProviderRegistry rpcRegistry = session.getSALService(RpcProviderRegistry.class);
- lfmDbService = rpcRegistry.getRpcService(MappingserviceService.class);
+ lfmDbService = rpcRegistry.getRpcService(OdlMappingserviceService.class);
LOG.debug("LFMDBSERVICE was FILLED! SESSION INITIATED");
}
import java.net.HttpURLConnection;
import org.apache.commons.lang3.exception.ExceptionUtils;
-import org.apache.commons.net.util.SubnetUtils;
-import org.apache.commons.net.util.SubnetUtils.SubnetInfo;
-import org.opendaylight.lispflowmapping.lisp.util.LispAFIConvertor;
+import org.opendaylight.lispflowmapping.lisp.util.LispAddressUtil;
import org.opendaylight.neutron.spi.INeutronSubnetAware;
import org.opendaylight.neutron.spi.NeutronSubnet;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.LispAFIAddress;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.lispaddress.LispAddressContainer;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.eid.container.Eid;
/**
* Lisp Service implementation of NeutronSubnetAware API Creation of a new
+ subnet.getName() + " Subnet Cidr: " + subnet.getCidr());
LOG.debug("Lisp Neutron Subnet: " + subnet.toString());
- int masklen = Integer.parseInt(subnet.getCidr().split("/")[1]);
- SubnetUtils util = new SubnetUtils(subnet.getCidr());
- SubnetInfo info = util.getInfo();
-
// Determine the IANA code for the subnet IP version
// Default is set to IPv4 for neutron subnets
- LispAFIAddress lispAddress = LispAFIConvertor.asIPAfiAddress(info.getNetworkAddress());
- LispAddressContainer addressContainer = LispAFIConvertor.toContainer(lispAddress);
+ Eid eid = LispAddressUtil.asIpv4PrefixEid(subnet.getCidr());
try {
- lispNeutronService.getMappingDbService().addKey((LispUtil.buildAddKeyInput(addressContainer,subnet.getNetworkUUID(), masklen)));
+ lispNeutronService.getMappingDbService().addKey(LispUtil.buildAddKeyInput(eid, subnet.getNetworkUUID()));
LOG.debug("Neutron Subnet Added to MapServer : Subnet name: "
+ subnet.getName() + " EID Prefix: "
- + addressContainer.toString() + " Key: "
+ + subnet.getCidr() + " Key: "
+ subnet.getNetworkUUID());
} catch (Exception e) {
LOG.error("Adding new subnet to lisp service mapping service failed. Subnet : "
+ "Key: " + subnet.getNetworkUUID());
LOG.debug("Lisp Neutron Subnet: " + subnet.toString());
- int masklen = Integer.parseInt(subnet.getCidr().split("/")[1]);
- SubnetUtils util = new SubnetUtils(subnet.getCidr());
- SubnetInfo info = util.getInfo();
-
// Determine the IANA code for the subnet IP version
// Default is set to IPv4 for neutron subnets
- LispAFIAddress lispAddress = LispAFIConvertor.asIPAfiAddress(info.getNetworkAddress());
- LispAddressContainer addressContainer = LispAFIConvertor.toContainer(lispAddress);
+ Eid eid = LispAddressUtil.asIpv4PrefixEid(subnet.getCidr());
try {
- lispNeutronService.getMappingDbService().removeKey(LispUtil.buildRemoveKeyInput(addressContainer, masklen));
+ lispNeutronService.getMappingDbService().removeKey(LispUtil.buildRemoveKeyInput(eid));
LOG.debug("Neutron Subnet Deleted from MapServer : Subnet name: "
+ subnet.getName() + " Eid Prefix: "
- + addressContainer.toString() + " Key: "
+ + subnet.getCidr() + " Key: "
+ subnet.getNetworkUUID());
} catch (Exception e) {
LOG.error("Deleting subnet's EID prefix from mapping service failed + Subnet: "
import java.util.List;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.EidToLocatorRecord.Action;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.lispaddress.LispAddressContainer;
+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.mapping.record.container.MappingRecord.Action;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.mapping.record.container.MappingRecordBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.mappingservice.rev150906.AddKeyInput;
import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.mappingservice.rev150906.AddKeyInputBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.mappingservice.rev150906.AddMappingInput;
import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.mappingservice.rev150906.RemoveKeyInputBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.mappingservice.rev150906.RemoveMappingInput;
import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.mappingservice.rev150906.RemoveMappingInputBuilder;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.mappingservice.rev150906.mapping.authkey.container.MappingAuthkeyBuilder;
/**
* LispUtil class has util functions for building inputs for LISP service RPCs.
// private static final Logger LOG = LoggerFactory.getLogger(LispUtil.class);
- public static AddMappingInput buildAddMappingInput(LispAddressContainer eid, List<LocatorRecord> locators, int mask) {
- AddMappingInputBuilder mib = new AddMappingInputBuilder();
+ public static AddMappingInput buildAddMappingInput(Eid eid, List<LocatorRecord> locators) {
+ MappingRecordBuilder mrb = new MappingRecordBuilder();
- mib.setAction(Action.NoAction).setAuthoritative(true).setLispAddressContainer(eid)
- .setLocatorRecord(locators).setMapVersion((short) 0).setMaskLength((short) mask)
+ mrb.setAction(Action.NoAction).setAuthoritative(true).setEid(eid)
+ .setLocatorRecord(locators).setMapVersion((short) 0)
.setRecordTtl(1440);
+
+ AddMappingInputBuilder mib = new AddMappingInputBuilder();
+ mib.setMappingRecord(mrb.build());
+
return mib.build();
}
- public static AddKeyInput buildAddKeyInput(LispAddressContainer eid, String net, int mask) {
+ public static AddKeyInput buildAddKeyInput(Eid eid, String net) {
AddKeyInputBuilder kib = new AddKeyInputBuilder();
- kib.setLispAddressContainer(eid).setAuthkey(net).setMaskLength((short)mask).setKeyType(1);
+ kib.setEid(eid).setMappingAuthkey(new MappingAuthkeyBuilder().setKeyString(net).setKeyType(1).build());
return kib.build();
}
- public static GetMappingInput buildGetMappingInput(LispAddressContainer eid, short mask) {
- return new GetMappingInputBuilder().setLispAddressContainer(eid).setMaskLength(mask).build();
+ public static GetMappingInput buildGetMappingInput(Eid eid) {
+ return new GetMappingInputBuilder().setEid(eid).build();
}
- public static RemoveMappingInput buildRemoveMappingInput(LispAddressContainer eid, int mask) {
+ public static RemoveMappingInput buildRemoveMappingInput(Eid eid) {
RemoveMappingInputBuilder rmib = new RemoveMappingInputBuilder();
- rmib.setLispAddressContainer(eid).setMaskLength((short)mask);
+ rmib.setEid(eid);
return rmib.build();
}
- public static RemoveKeyInput buildRemoveKeyInput(LispAddressContainer eid, int mask) {
+ public static RemoveKeyInput buildRemoveKeyInput(Eid eid) {
RemoveKeyInputBuilder kib = new RemoveKeyInputBuilder();
- kib.setLispAddressContainer(eid).setMaskLength((short)mask);
+ kib.setEid(eid);
return kib.build();
}
-}
\ No newline at end of file
+}
<modules>
<module>lisp-proto</module>
<module>api</module>
- <!--
<module>inmemorydb</module>
<module>implementation</module>
<module>southbound</module>
<module>neutron</module>
<module>shell</module>
- -->
</modules>
<dependencyManagement>
+++ /dev/null
-/*
-* Generated file
-*
-* Generated from: yang module name: lfm-mappingservice-sb-impl yang module local name: lfm-mappingservice-sb
-* Generated by: org.opendaylight.controller.config.yangjmxgenerator.plugin.JMXGenerator
-* Generated at: Mon May 11 18:08:47 PDT 2015
-*
-* Do not modify this file unless it is present under src/main directory
-*/
-package org.opendaylight.controller.config.yang.config.lfm_mappingservice_sb.impl;
-public class LfmMappingServiceSbModuleFactory extends org.opendaylight.controller.config.yang.config.lfm_mappingservice_sb.impl.AbstractLfmMappingServiceSbModuleFactory {
-
-}
-/*
- * Copyright (c) 2015 Cisco Systems, Inc. All rights reserved.
- *
- * This program and the accompanying materials are made available under the
- * terms of the Eclipse Public License v1.0 which accompanies this distribution,
- * and is available at http://www.eclipse.org/legal/epl-v10.html
- */
-
-package org.opendaylight.controller.config.yang.config.lfm_mappingservice_sb.impl;
+package org.opendaylight.controller.config.yang.config.lisp_sb.impl;
import org.opendaylight.lispflowmapping.southbound.LispSouthboundPlugin;
-import org.slf4j.LoggerFactory;
import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
-public class LfmMappingServiceSbModule extends org.opendaylight.controller.config.yang.config.lfm_mappingservice_sb.impl.AbstractLfmMappingServiceSbModule {
+public class LfmMappingServiceSbModule extends org.opendaylight.controller.config.yang.config.lisp_sb.impl.AbstractLfmMappingServiceSbModule {
private final static Logger LOG = LoggerFactory.getLogger(LfmMappingServiceSbModule.class);
private LispSouthboundPlugin sbPlugin;
super(identifier, dependencyResolver);
}
- public LfmMappingServiceSbModule(org.opendaylight.controller.config.api.ModuleIdentifier identifier, org.opendaylight.controller.config.api.DependencyResolver dependencyResolver, org.opendaylight.controller.config.yang.config.lfm_mappingservice_sb.impl.LfmMappingServiceSbModule oldModule, java.lang.AutoCloseable oldInstance) {
+ public LfmMappingServiceSbModule(org.opendaylight.controller.config.api.ModuleIdentifier identifier, org.opendaylight.controller.config.api.DependencyResolver dependencyResolver, org.opendaylight.controller.config.yang.config.lisp_sb.impl.LfmMappingServiceSbModule oldModule, java.lang.AutoCloseable oldInstance) {
super(identifier, dependencyResolver, oldModule, oldInstance);
}
--- /dev/null
+/*
+* Generated file
+*
+* Generated from: yang module name: odl-lisp-sb-impl yang module local name: lisp-sb-impl
+* Generated by: org.opendaylight.controller.config.yangjmxgenerator.plugin.JMXGenerator
+* Generated at: Fri Nov 27 12:37:22 EET 2015
+*
+* Do not modify this file unless it is present under src/main directory
+*/
+package org.opendaylight.controller.config.yang.config.lisp_sb.impl;
+public class LfmMappingServiceSbModuleFactory extends org.opendaylight.controller.config.yang.config.lisp_sb.impl.AbstractLfmMappingServiceSbModuleFactory {
+
+}
import org.opendaylight.lispflowmapping.southbound.lisp.LispXtrSouthboundService;
import org.opendaylight.lispflowmapping.type.sbplugin.IConfigLispSouthboundPlugin;
import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.MessageType;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.transportaddress.TransportAddress;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.sb.rev150904.LispSbService;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.transport.address.TransportAddress;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.sb.rev150904.OdlLispSbService;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
private volatile String bindingAddress = null;
private volatile int xtrPort = LispMessage.XTR_PORT_NUM;
private volatile boolean listenOnXtrPort = false;
- private BindingAwareBroker.RpcRegistration<LispSbService> sbRpcRegistration;
+ private BindingAwareBroker.RpcRegistration<OdlLispSbService> sbRpcRegistration;
private DatagramSocket xtrSocket;
private LispSouthboundStats statistics = new LispSouthboundStats();
LOG.info("LISP (RFC6830) southbound plugin is initializing...");
final LispSouthboundRPC sbRpcHandler = new LispSouthboundRPC(this);
- sbRpcRegistration = rpcRegistry.addRpcImplementation(LispSbService.class, sbRpcHandler);
+ sbRpcRegistration = rpcRegistry.addRpcImplementation(OdlLispSbService.class, sbRpcHandler);
broker.registerProvider(this);
synchronized (startLock) {
import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.MessageType;
import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.sb.rev150904.GetStatsOutput;
import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.sb.rev150904.GetStatsOutputBuilder;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.sb.rev150904.LispSbService;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.sb.rev150904.OdlLispSbService;
import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.sb.rev150904.SendMapNotifyInput;
import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.sb.rev150904.SendMapRegisterInput;
import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.sb.rev150904.SendMapReplyInput;
* @author Lorand Jakab (lojakab@cisco.com)
*/
-public class LispSouthboundRPC implements LispSbService {
+public class LispSouthboundRPC implements OdlLispSbService {
protected static final Logger LOG = LoggerFactory.getLogger(LispSouthboundRPC.class);
}
return max;
}
-}
\ No newline at end of file
+}
import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.MapRequest;
import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.MapReply;
import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.RequestMappingBuilder;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.transportaddress.TransportAddressBuilder;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.transport.address.TransportAddressBuilder;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev100924.PortNumber;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.MapRequest;
import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.XtrReplyMappingBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.XtrRequestMappingBuilder;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.transportaddress.TransportAddressBuilder;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.transport.address.TransportAddressBuilder;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev100924.PortNumber;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
public static MapRegister convertMapRegister(
org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.MapRegister mapRegister) {
return new MapRegisterBuilder().setAuthenticationData(mapRegister.getAuthenticationData())
- .setEidToLocatorRecord(mapRegister.getEidToLocatorRecord()).setKeyId(mapRegister.getKeyId())
+ .setMappingRecordItem(mapRegister.getMappingRecordItem()).setKeyId(mapRegister.getKeyId())
.setNonce(mapRegister.getNonce()).setProxyMapReply(mapRegister.isProxyMapReply())
.setWantMapNotify(mapRegister.isWantMapNotify()).setXtrSiteIdPresent(mapRegister.isXtrSiteIdPresent())
.setXtrId(mapRegister.getXtrId()).setSiteId(mapRegister.getSiteId()).build();
public static MapNotify convertMapNotify(
org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.MapNotify mapNotify) {
return new MapNotifyBuilder().setAuthenticationData(mapNotify.getAuthenticationData())
- .setEidToLocatorRecord(mapNotify.getEidToLocatorRecord()).setKeyId(mapNotify.getKeyId())
+ .setMappingRecordItem(mapNotify.getMappingRecordItem()).setKeyId(mapNotify.getKeyId())
.setNonce(mapNotify.getNonce()).setXtrSiteIdPresent(mapNotify.isXtrSiteIdPresent())
.setXtrId(mapNotify.getXtrId()).setSiteId(mapNotify.getSiteId()).build();
}
public static MapRequest convertMapRequest(
org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.MapRequest mapRequest) {
return new MapRequestBuilder().setAuthoritative(mapRequest.isAuthoritative())
- .setEidRecord(mapRequest.getEidRecord()).setItrRloc(mapRequest.getItrRloc())
+ .setEidItem(mapRequest.getEidItem()).setItrRloc(mapRequest.getItrRloc())
.setMapDataPresent(mapRequest.isMapDataPresent()).setMapReply(mapRequest.getMapReply())
.setNonce(mapRequest.getNonce()).setPitr(mapRequest.isPitr()).setProbe(mapRequest.isProbe())
.setSmr(mapRequest.isSmr()).setSmrInvoked(mapRequest.isSmrInvoked())
public static MapReply convertMapReply(
org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.MapReply mapReply) {
return new MapReplyBuilder().setEchoNonceEnabled(mapReply.isEchoNonceEnabled())
- .setEidToLocatorRecord(mapReply.getEidToLocatorRecord()).setNonce(mapReply.getNonce())
+ .setMappingRecordItem(mapReply.getMappingRecordItem()).setNonce(mapReply.getNonce())
.setProbe(mapReply.isProbe()).setSecurityEnabled(mapReply.isSecurityEnabled()).build();
}
import java.util.List;
import junitx.framework.ArrayAssert;
-import junitx.framework.Assert;
import org.apache.commons.lang3.ArrayUtils;
import org.jmock.api.Invocation;
import org.junit.Ignore;
import org.junit.Test;
import org.opendaylight.controller.md.sal.binding.api.NotificationPublishService;
-import org.opendaylight.lispflowmapping.lisp.type.AddressFamilyNumberEnum;
import org.opendaylight.lispflowmapping.lisp.type.LispMessage;
import org.opendaylight.lispflowmapping.lisp.type.LispMessageEnum;
import org.opendaylight.lispflowmapping.lisp.util.ByteUtil;
-import org.opendaylight.lispflowmapping.lisp.util.LispAFIConvertor;
+import org.opendaylight.lispflowmapping.lisp.util.LispAddressUtil;
import org.opendaylight.lispflowmapping.lisp.util.MapNotifyBuilderHelper;
+import org.opendaylight.lispflowmapping.lisp.util.MaskUtil;
import org.opendaylight.lispflowmapping.lisp.serializer.MapNotifySerializer;
import org.opendaylight.lispflowmapping.lisp.serializer.MapReplySerializer;
import org.opendaylight.lispflowmapping.southbound.lisp.exception.LispMalformedPacketException;
import org.opendaylight.lispflowmapping.tools.junit.BaseTestCase;
+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.Ipv4Afi;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.lisp.address.types.rev151105.Ipv4PrefixAfi;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.lisp.address.types.rev151105.Ipv6PrefixAfi;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.lisp.address.types.rev151105.lisp.address.address.Ipv6Prefix;
import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.AddMapping;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.EidToLocatorRecord.Action;
import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.MapRegister;
import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.MapRequest;
import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.RequestMapping;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.eidrecords.EidRecord;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.eidtolocatorrecords.EidToLocatorRecord;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.eidtolocatorrecords.EidToLocatorRecordBuilder;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.lispaddress.LispAddressContainer;
+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.eid.list.EidItem;
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;
import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.mapnotifymessage.MapNotifyBuilder;
+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.MappingRecord.Action;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.mapping.record.container.MappingRecordBuilder;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.mapping.record.list.MappingRecordItem;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.mapping.record.list.MappingRecordItemBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.mapreplymessage.MapReplyBuilder;
import org.opendaylight.yangtools.yang.binding.Notification;
// private ValueSaverAction<MapRequest> mapRequestSaver;
private MapNotifyBuilder mapNotifyBuilder;
private MapReplyBuilder mapReplyBuilder;
- private EidToLocatorRecordBuilder eidToLocatorBuilder;
+ private MappingRecordBuilder mappingRecordBuilder;
private interface MapReplyIpv4SingleLocatorPos {
int RECORD_COUNT = 3;
+ "0050 2a cd 39 c8 d6 08 00 01 01 02 03 04 00 01 c0 a8 88 0a 00 20 " //
+ "0060 00 01 01 02 03 04"));
mapReplyBuilder = new MapReplyBuilder();
- mapReplyBuilder.setEidToLocatorRecord(new ArrayList<EidToLocatorRecord>());
+ mapReplyBuilder.setMappingRecordItem(new ArrayList<MappingRecordItem>());
mapReplyBuilder.setNonce((long) 0);
mapReplyBuilder.setEchoNonceEnabled(false);
mapReplyBuilder.setProbe(true);
mapReplyBuilder.setSecurityEnabled(true);
- eidToLocatorBuilder = new EidToLocatorRecordBuilder();
+ mappingRecordBuilder = new MappingRecordBuilder();
String ip = "0.0.0.0";
- eidToLocatorBuilder.setLispAddressContainer(LispAFIConvertor.asIPv4Prefix(ip, 0));
- eidToLocatorBuilder.setLocatorRecord(new ArrayList<LocatorRecord>());
- eidToLocatorBuilder.setRecordTtl(10);
- eidToLocatorBuilder.setMapVersion((short) 0);
- eidToLocatorBuilder.setMaskLength((short) 0);
- eidToLocatorBuilder.setAction(Action.NativelyForward);
- eidToLocatorBuilder.setAuthoritative(false);
+ mappingRecordBuilder.setEid(LispAddressUtil.asIpv4PrefixEid(ip + "/0"));
+ mappingRecordBuilder.setLocatorRecord(new ArrayList<LocatorRecord>());
+ mappingRecordBuilder.setRecordTtl(10);
+ mappingRecordBuilder.setMapVersion((short) 0);
+ mappingRecordBuilder.setMaskLength((short) 0);
+ mappingRecordBuilder.setAction(Action.NativelyForward);
+ mappingRecordBuilder.setAuthoritative(false);
// eidToLocatorBuilder.setPrefix(new LispIpv4Address(0));
// mapReply.addEidToLocator(eidToLocatorBuilder);
handleMapRegisterPacket(mapRegisterPacket);
- List<EidToLocatorRecord> eidRecords = lastMapRegister().getEidToLocatorRecord();
+ List<MappingRecordItem> eidRecords = lastMapRegister().getMappingRecordItem();
assertEquals(1, eidRecords.size());
- EidToLocatorRecord eidRecord = eidRecords.get(0);
+ MappingRecord eidRecord = eidRecords.get(0).getMappingRecord();
assertEquals(2, eidRecord.getLocatorRecord().size());
- assertEquals(LispAFIConvertor.toContainer(LispAFIConvertor.asIPAfiAddress("10.1.0.110")), eidRecord.getLocatorRecord().get(0).getLispAddressContainer());
- assertEquals(LispAFIConvertor.toContainer(LispAFIConvertor.asIPAfiAddress("192.168.136.51")), eidRecord.getLocatorRecord().get(1).getLispAddressContainer());
+ assertEquals(LispAddressUtil.asIpv4Rloc("10.1.0.110"), eidRecord.getLocatorRecord().get(0).getRloc());
+ assertEquals(LispAddressUtil.asIpv4Rloc("192.168.136.51"), eidRecord.getLocatorRecord().get(1).getRloc());
}
@Test
handleMapRegisterPacket(mapRegisterPacket);
- EidToLocatorRecord eidToLocatorRecord = lastMapRegister().getEidToLocatorRecord().get(0);
- assertEquals(LispAFIConvertor.asIPv6Address("2610:d0:ffff:192:0:0:0:1"), eidToLocatorRecord.getLispAddressContainer());
- assertEquals(AddressFamilyNumberEnum.IP6,
- AddressFamilyNumberEnum.valueOf(LispAFIConvertor.toAFI(eidToLocatorRecord.getLispAddressContainer()).getAfi()));
+ MappingRecord eidToLocatorRecord = lastMapRegister().getMappingRecordItem().get(0).getMappingRecord();
+ assertEquals("2610:d0:ffff:192:0:0:0:1/128",
+ ((Ipv6Prefix) eidToLocatorRecord.getEid().getAddress()).getIpv6Prefix().getValue());
+ assertEquals(Ipv6PrefixAfi.class, eidToLocatorRecord.getEid().getAddressType());
- assertEquals(LispAFIConvertor.asIPAfiAddress("10.0.58.156"), LispAFIConvertor.toAFI(eidToLocatorRecord.getLocatorRecord().get(0).getLispAddressContainer()));
+ assertEquals(LispAddressUtil.asIpv4Rloc("10.0.58.156"), eidToLocatorRecord.getLocatorRecord().get(0).getRloc());
}
@Test
oneOf(nps).putNotification(with(lispNotificationSaver));
handleMapRegisterPacket(mapRegisterPacket);
- EidToLocatorRecord eidToLocator = lastMapRegister().getEidToLocatorRecord().get(0);
- assertEquals(LispAFIConvertor.asIPv4Address("153.16.254.1"), eidToLocator.getLispAddressContainer());
+ MappingRecord eidToLocator = lastMapRegister().getMappingRecordItem().get(0).getMappingRecord();
+ assertEquals(LispAddressUtil.asIpv4PrefixEid("153.16.254.1/32"), eidToLocator.getEid());
assertEquals(1, eidToLocator.getLocatorRecord().size());
- assertEquals(LispAFIConvertor.asIPAfiAddress("192.168.136.10"), LispAFIConvertor.toAFI(eidToLocator.getLocatorRecord().get(0).getLispAddressContainer()));
+ assertEquals(LispAddressUtil.asIpv4Rloc("192.168.136.10"), eidToLocator.getLocatorRecord().get(0).getRloc());
}
@Test
}
private DatagramPacket lastMapNotifyPacket() {
- if (mapNotifyBuilder.getEidToLocatorRecord() == null) {
- mapNotifyBuilder.setEidToLocatorRecord(new ArrayList<EidToLocatorRecord>());
+ if (mapNotifyBuilder.getMappingRecordItem() == null) {
+ mapNotifyBuilder.setMappingRecordItem(new ArrayList<MappingRecordItem>());
}
- mapNotifyBuilder.getEidToLocatorRecord().add(eidToLocatorBuilder.build());
+ mapNotifyBuilder.getMappingRecordItem().add(new MappingRecordItemBuilder().setMappingRecord(
+ mappingRecordBuilder.build()).build());
mapNotifyBuilder.setNonce((long) 0);
mapNotifyBuilder.setKeyId((short) 0);
mapNotifyBuilder.setAuthenticationData(new byte[0]);
public void mapRequest__VerifyBasicFields() throws Exception {
oneOf(nps).putNotification(with(lispNotificationSaver));
handleMapRequestAsByteArray(mapRequestPacket);
- List<EidRecord> eids = lastMapRequest().getEidRecord();
+ List<EidItem> eids = lastMapRequest().getEidItem();
assertEquals(1, eids.size());
- LispAddressContainer lispAddress = eids.get(0).getLispAddressContainer();
- assertTrue(LispAFIConvertor.toAFI(lispAddress) instanceof org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.lispaddress.lispaddresscontainer.address.ipv4.Ipv4Address);
- assertEquals(LispAFIConvertor.asIPv4Address("1.2.3.4"), lispAddress);
- assertEquals((byte) 0x20, eids.get(0).getMask().byteValue());
+ Eid lispAddress = eids.get(0).getEid();
+ assertEquals(Ipv4PrefixAfi.class, lispAddress.getAddressType());
+ assertEquals(LispAddressUtil.asIpv4PrefixEid("1.2.3.4/32"), lispAddress);
assertEquals(0x3d8d2acd39c8d608L, lastMapRequest().getNonce().longValue());
- // assertEquals(AddressFamilyNumberEnum.RESERVED,
- // AddressFamilyNumberEnum.valueOf(LispAFIToContainerConvertorFactory.toAFI(
- // lastMapRequest().getSourceEid().getLispAddressContainer()).getAfi()));
}
@Test
// ret(mapReply);
handleMapRequestAsByteArray(mapRequestPacket);
- assertEquals(LispAFIConvertor.asIPv6AfiAddress("2610:d0:ffff:192:0:0:0:1"), LispAFIConvertor.toAFI(lastMapRequest().getSourceEid().getLispAddressContainer()));
- assertEquals(LispAFIConvertor.asIPv6Address("2610:d0:ffff:192:0:0:0:2"), lastMapRequest().getEidRecord().get(0).getLispAddressContainer());
+ assertEquals(LispAddressUtil.asIpv6Eid("2610:d0:ffff:192:0:0:0:1"), lastMapRequest().getSourceEid().getEid());
+ assertEquals(LispAddressUtil.asIpv6PrefixEid("2610:d0:ffff:192:0:0:0:2/128"), lastMapRequest().getEidItem().get(0).getEid());
}
@Ignore
// ret(mapReply);
handleMapRequestAsByteArray(mapRequestPacket);
- Assert.assertNotEquals(AddressFamilyNumberEnum.IP, LispAFIConvertor.toAFI(lastMapRequest().getSourceEid().getLispAddressContainer()));
+ assertEquals(Ipv4Afi.class, lastMapRequest().getSourceEid().getEid().getAddressType());
}
@Test
@Ignore
public void mapReply__VerifyBasicIPv4Fields() throws Exception {
- eidToLocatorBuilder.setMaskLength((short) 0x20).setLispAddressContainer(LispAFIConvertor.toContainer(LispAFIConvertor.asIPAfiAddress("10.0.20.200")));
+ mappingRecordBuilder.setEid(LispAddressUtil.asIpv4PrefixEid("10.0.20.200/32"));
mapReplyBuilder.setNonce(0x3d8d2acd39c8d608L);
stubHandleRequest();
byte expectedRecordCount = (byte) 1;
assertEquals(expectedRecordCount, result[MapReplyIpv4SingleLocatorPos.RECORD_COUNT]);
- assertEquals(eidToLocatorBuilder.getMaskLength().byteValue(), result[MapReplyIpv4SingleLocatorPos.EID_MASK_LEN]);
- assertEquals(AddressFamilyNumberEnum.IP.getIanaCode(), ByteUtil.getShort(result, MapReplyIpv4SingleLocatorPos.AFI_TYPE));
+ assertEquals(MaskUtil.getMaskForAddress(mappingRecordBuilder.getEid().getAddress()), result[MapReplyIpv4SingleLocatorPos.EID_MASK_LEN]);
+ assertEquals(AddressFamily.IpV4.getIntValue(), ByteUtil.getInt(result, MapReplyIpv4SingleLocatorPos.AFI_TYPE));
assertEquals(0x0a0014c8, ByteUtil.getInt(result, MapReplyIpv4SingleLocatorPos.EID_PREFIX));
}
@Test
@Ignore
public void mapReply__VerifyBasicIPv6() throws Exception {
- eidToLocatorBuilder.setMaskLength((short) 0x80).setLispAddressContainer(LispAFIConvertor.toContainer(LispAFIConvertor.asIPv6AfiAddress("0:0:0:0:0:0:0:1")));
+ mappingRecordBuilder.setEid(LispAddressUtil.asIpv6PrefixEid("0:0:0:0:0:0:0:1/128"));
stubHandleRequest();
byte expectedRecordCount = (byte) 1;
assertEquals(expectedRecordCount, result[MapReplyIpv4SingleLocatorPos.RECORD_COUNT]);
- assertEquals(eidToLocatorBuilder.getMaskLength().byteValue(), result[MapReplyIpv4SingleLocatorPos.EID_MASK_LEN]);
- assertEquals(AddressFamilyNumberEnum.IP6.getIanaCode(), ByteUtil.getShort(result, MapReplyIpv4SingleLocatorPos.AFI_TYPE));
+ assertEquals(MaskUtil.getMaskForAddress(mappingRecordBuilder.getEid().getAddress()), result[MapReplyIpv4SingleLocatorPos.EID_MASK_LEN]);
+ assertEquals(AddressFamily.IpV6.getIntValue(), ByteUtil.getInt(result, MapReplyIpv4SingleLocatorPos.AFI_TYPE));
byte[] expectedIpv6 = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1 };
ArrayAssert.assertEquals(expectedIpv6, Arrays.copyOfRange(result, 24, 40));
@Test
@Ignore
public void mapReply__VerifyIPv6EidAndLocator() throws Exception {
- eidToLocatorBuilder.setLispAddressContainer(LispAFIConvertor.toContainer(LispAFIConvertor.asIPv6AfiAddress("0:0:0:0:0:0:0:1")));
- eidToLocatorBuilder.getLocatorRecord().add(
- new LocatorRecordBuilder().setLispAddressContainer(LispAFIConvertor.toContainer(LispAFIConvertor.asIPv6AfiAddress("0:0:0:0:0:0:0:2"))).build());
+ mappingRecordBuilder.setEid(LispAddressUtil.asIpv6PrefixEid("0:0:0:0:0:0:0:1/128"));
+ mappingRecordBuilder.getLocatorRecord().add(
+ new LocatorRecordBuilder().setRloc(LispAddressUtil.asIpv6Rloc("0:0:0:0:0:0:0:2")).build());
stubHandleRequest();
@Test
@Ignore
public void mapReply__WithNonRoutableSingleLocator() throws Exception {
- eidToLocatorBuilder.setMaskLength((short) 0x20).setLispAddressContainer(LispAFIConvertor.toContainer(LispAFIConvertor.asIPAfiAddress("10.0.20.200")));
- eidToLocatorBuilder.getLocatorRecord().add(
- new LocatorRecordBuilder().setRouted(false).setLispAddressContainer(LispAFIConvertor.toContainer(LispAFIConvertor.asIPAfiAddress("4.3.2.1"))).build());
+ mappingRecordBuilder.setEid(LispAddressUtil.asIpv4PrefixEid("10.0.20.200/32"));
+ mappingRecordBuilder.getLocatorRecord().add(
+ new LocatorRecordBuilder().setRouted(false).setRloc(LispAddressUtil.asIpv4Rloc("4.3.2.1")).build());
stubHandleRequest();
byte[] result = handleMapRequestAsByteArray(mapRequestPacket);
@Test
@Ignore
public void mapReply__WithSingleLocator() throws Exception {
- eidToLocatorBuilder.setMaskLength((short) 0x20)//
- .setLispAddressContainer(LispAFIConvertor.toContainer(LispAFIConvertor.asIPAfiAddress("10.0.20.200")));
- eidToLocatorBuilder.getLocatorRecord().add(
- new LocatorRecordBuilder().setRouted(true).setLispAddressContainer(LispAFIConvertor.toContainer(LispAFIConvertor.asIPAfiAddress("4.3.2.1"))).build());
+ mappingRecordBuilder.setEid(LispAddressUtil.asIpv4PrefixEid("10.0.20.200/32"));
+ mappingRecordBuilder.getLocatorRecord().add(
+ new LocatorRecordBuilder().setRouted(true).setRloc(LispAddressUtil.asIpv4Rloc("4.3.2.1")).build());
stubHandleRequest();
byte[] result = handleMapRequestAsByteArray(mapRequestPacket);
byte expectedLocCount = 1;
assertEquals(expectedLocCount, result[MapReplyIpv4SingleLocatorPos.LOCATOR_COUNT]);
- assertEquals(AddressFamilyNumberEnum.IP.getIanaCode(), ByteUtil.getShort(result, MapReplyIpv4SingleLocatorPos.LOC_AFI));
+ assertEquals(AddressFamily.IpV4.getIntValue(), ByteUtil.getInt(result, MapReplyIpv4SingleLocatorPos.LOC_AFI));
assertEquals(0x04030201, ByteUtil.getInt(result, MapReplyIpv4SingleLocatorPos.LOCATOR));
assertEquals(0x01, result[MapReplyIpv4SingleLocatorPos.LOCATOR_RBIT] & 0x01);
@Test
@Ignore
public void mapReply__WithMultipleLocator() throws Exception {
- eidToLocatorBuilder.getLocatorRecord().add(
- new LocatorRecordBuilder().setRouted(true).setLispAddressContainer(LispAFIConvertor.toContainer(LispAFIConvertor.asIPAfiAddress("4.3.2.1"))).build());
- eidToLocatorBuilder.getLocatorRecord().add(
- new LocatorRecordBuilder().setRouted(true).setLispAddressContainer(LispAFIConvertor.toContainer(LispAFIConvertor.asIPv6AfiAddress("0:0:0:0:0:0:0:1"))).build());
+ mappingRecordBuilder.getLocatorRecord().add(
+ new LocatorRecordBuilder().setRouted(true).setRloc(LispAddressUtil.asIpv4Rloc("4.3.2.1")).build());
+ mappingRecordBuilder.getLocatorRecord().add(
+ new LocatorRecordBuilder().setRouted(true).setRloc(LispAddressUtil.asIpv6Rloc("0:0:0:0:0:0:0:1")).build());
stubHandleRequest();
byte[] result = handleMapRequestAsByteArray(mapRequestPacket);
assertEquals(2, result[MapReplyIpv4SingleLocatorPos.LOCATOR_COUNT]);
- assertEquals(AddressFamilyNumberEnum.IP.getIanaCode(), ByteUtil.getShort(result, MapReplyIpv4SingleLocatorPos.LOC_AFI));
+ assertEquals(AddressFamily.IpV4.getIntValue(), ByteUtil.getInt(result, MapReplyIpv4SingleLocatorPos.LOC_AFI));
assertEquals(0x04030201, ByteUtil.getInt(result, MapReplyIpv4SingleLocatorPos.LOCATOR));
assertEquals(0x01, result[MapReplyIpv4SingleLocatorPos.LOCATOR_RBIT] & 0x01);
- assertEquals(AddressFamilyNumberEnum.IP6.getIanaCode(), ByteUtil.getShort(result, MapReplyIpv4SecondLocatorPos.LOC_AFI));
+ assertEquals(AddressFamily.IpV6.getIntValue(), ByteUtil.getInt(result, MapReplyIpv4SecondLocatorPos.LOC_AFI));
byte[] expectedIpv6Rloc = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1 };
ArrayAssert.assertEquals(expectedIpv6Rloc,
Code Review / lispflowmapping.git / commitdiff