/**
* The mapping service key in the DAO.
*/
-public interface IMappingServiceKey {
+public interface IMappingKey {
/**
* @return The eid of the key
/**
* A RLOC in the mapping service with it's properties.
*/
-public class MappingServiceRLOCGroup {
+public class RLOCGroup {
private List<LocatorRecord> records;
private int ttl;
private boolean authoritative;
private Date registerdDate;
- public MappingServiceRLOCGroup(int ttl, Action action, boolean authoritative) {
+ public RLOCGroup(int ttl, Action action, boolean authoritative) {
this(ttl, action, authoritative, new Date(System.currentTimeMillis()));
}
- public MappingServiceRLOCGroup(int ttl, Action action, boolean authoritative, Date registerdDate) {
+ public RLOCGroup(int ttl, Action action, boolean authoritative, Date registerdDate) {
super();
this.records = new ArrayList<>();
this.ttl = ttl;
return records;
}
- public MappingServiceRLOCGroup addRecord(LocatorRecord record) {
+ public RLOCGroup addRecord(LocatorRecord record) {
this.records.add(record);
return this;
}
return ttl;
}
- public MappingServiceRLOCGroup setTtl(int ttl) {
+ public RLOCGroup setTtl(int ttl) {
this.ttl = ttl;
return this;
}
return action;
}
- public MappingServiceRLOCGroup setAction(Action action) {
+ public RLOCGroup setAction(Action action) {
this.action = action;
return this;
}
return authoritative;
}
- public MappingServiceRLOCGroup setAuthoritative(boolean authoritative) {
+ public RLOCGroup setAuthoritative(boolean authoritative) {
this.authoritative = authoritative;
return this;
}
return registerdDate;
}
- public MappingServiceRLOCGroup setRegisterdDate(Date registerdDate) {
+ public RLOCGroup setRegisterdDate(Date registerdDate) {
this.registerdDate = registerdDate;
return this;
}
return false;
if (getClass() != obj.getClass())
return false;
- MappingServiceRLOCGroup other = (MappingServiceRLOCGroup) obj;
+ RLOCGroup other = (RLOCGroup) obj;
if (action != other.action)
return false;
if (authoritative != other.authoritative)
/**
* Request source RLOC in the mapping service with it's properties.
*/
-public class MappingServiceSubscriberRLOC {
+public class SubscriberRLOC {
private LispAddressContainer rloc;
private LispAddressContainer eid;
private Date lastRequestDate;
private static final long SUBSCRIBER_TIMEOUT = 600000; /* milliseconds */
- public MappingServiceSubscriberRLOC(LispAddressContainer srcRloc, LispAddressContainer srcEid) {
+ public SubscriberRLOC(LispAddressContainer srcRloc, LispAddressContainer srcEid) {
this(srcRloc, srcEid, new Date(System.currentTimeMillis()));
}
- public MappingServiceSubscriberRLOC(LispAddressContainer srcRloc, LispAddressContainer srcEid,
+ public SubscriberRLOC(LispAddressContainer srcRloc, LispAddressContainer srcEid,
Date lastRequestDate) {
super();
this.rloc = srcRloc;
return false;
if (getClass() != obj.getClass())
return false;
- MappingServiceSubscriberRLOC other = (MappingServiceSubscriberRLOC) obj;
+ SubscriberRLOC other = (SubscriberRLOC) obj;
if (!rloc.equals(other.rloc))
return false;
return true;
import org.opendaylight.lispflowmapping.interfaces.dao.ILispDAO;
import org.opendaylight.lispflowmapping.interfaces.dao.IRowVisitor;
import org.opendaylight.lispflowmapping.interfaces.dao.MappingEntry;
-import org.opendaylight.lispflowmapping.interfaces.dao.MappingServiceRLOCGroup;
+import org.opendaylight.lispflowmapping.interfaces.dao.RLOCGroup;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
public void cleanOld() {
getAll(new IRowVisitor() {
public void visitRow(Object keyId, String valueKey, Object value) {
- if (value instanceof MappingServiceRLOCGroup) {
- MappingServiceRLOCGroup rloc = (MappingServiceRLOCGroup) value;
+ if (value instanceof RLOCGroup) {
+ RLOCGroup rloc = (RLOCGroup) value;
if (isExpired(rloc)) {
removeSpecific(keyId, valueKey);
}
}
}
- private boolean isExpired(MappingServiceRLOCGroup rloc) {
+ private boolean isExpired(RLOCGroup rloc) {
return System.currentTimeMillis() - rloc.getRegisterdDate().getTime() > TimeUnit.MILLISECONDS.convert(recordTimeOut, timeUnit);
}
});
<artifactId>org.eclipse.osgi</artifactId>
</dependency>
</dependencies>
-
- <build>
- <plugins>
- <plugin>
- <groupId>org.apache.felix</groupId>
- <artifactId>maven-bundle-plugin</artifactId>
- <extensions>true</extensions>
- <configuration>
- <instructions>
- <Export-Package>
- org.opendaylight.lispflowmapping.implementation,
- org.opendaylight.lispflowmapping.implementation.serializer,
- org.opendaylight.lispflowmapping.implementation.util
- </Export-Package>
- </instructions>
- </configuration>
- </plugin>
- </plugins>
- </build>
</project>
import org.opendaylight.controller.md.sal.binding.api.DataBroker;
import org.opendaylight.lispflowmapping.implementation.mdsal.DataStoreBackEnd;
-import org.opendaylight.lispflowmapping.implementation.util.MapServerMapResolverUtil;
import org.opendaylight.lispflowmapping.implementation.util.RPCInputConvertorUtil;
+import org.opendaylight.lispflowmapping.lisp.util.MapServerMapResolverUtil;
import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.control.plane.rev150314.MapReply;
import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.control.plane.rev150314.MapRequest;
import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.mapping.database.rev150314.AddKeyInput;
import org.opendaylight.controller.sal.binding.api.NotificationService;
import org.opendaylight.controller.sal.binding.api.RpcProviderRegistry;
import org.opendaylight.lispflowmapping.implementation.config.ConfigIni;
-import org.opendaylight.lispflowmapping.implementation.dao.MappingServiceKey;
-import org.opendaylight.lispflowmapping.implementation.dao.MappingServiceNoMaskKey;
-import org.opendaylight.lispflowmapping.implementation.lisp.AbstractLispComponent;
+import org.opendaylight.lispflowmapping.implementation.dao.MappingKey;
+import org.opendaylight.lispflowmapping.implementation.dao.MappingNoMaskKey;
import org.opendaylight.lispflowmapping.implementation.lisp.MapResolver;
import org.opendaylight.lispflowmapping.implementation.lisp.MapServer;
import org.opendaylight.lispflowmapping.implementation.mdsal.AuthenticationKeyDataListener;
import org.opendaylight.lispflowmapping.implementation.mdsal.DataStoreBackEnd;
import org.opendaylight.lispflowmapping.implementation.mdsal.MappingDataListener;
-import org.opendaylight.lispflowmapping.implementation.serializer.LispMessage;
-import org.opendaylight.lispflowmapping.implementation.util.LispAFIConvertor;
-import org.opendaylight.lispflowmapping.implementation.util.LispAddressStringifier;
+import org.opendaylight.lispflowmapping.implementation.util.DAOSubKeys;
import org.opendaylight.lispflowmapping.implementation.util.LispNotificationHelper;
-import org.opendaylight.lispflowmapping.implementation.util.MapServerMapResolverUtil;
+import org.opendaylight.lispflowmapping.lisp.type.LispMessage;
import org.opendaylight.lispflowmapping.interfaces.dao.ILispDAO;
import org.opendaylight.lispflowmapping.interfaces.dao.ILispTypeConverter;
import org.opendaylight.lispflowmapping.interfaces.dao.IRowVisitor;
import org.opendaylight.lispflowmapping.interfaces.lisp.IMapRequestResultHandler;
import org.opendaylight.lispflowmapping.interfaces.lisp.IMapResolverAsync;
import org.opendaylight.lispflowmapping.interfaces.lisp.IMapServerAsync;
+import org.opendaylight.lispflowmapping.lisp.util.LispAFIConvertor;
+import org.opendaylight.lispflowmapping.lisp.util.LispAddressStringifier;
+import org.opendaylight.lispflowmapping.lisp.util.MapServerMapResolverUtil;
import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.control.plane.rev150314.AddMapping;
import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.control.plane.rev150314.LfmControlPlaneService;
import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.control.plane.rev150314.MapNotify;
class LispIpv6AddressInMemoryConverter implements ILispTypeConverter<Ipv6Address, Integer> {
}
- class MappingServiceKeyConvertor implements ILispTypeConverter<MappingServiceKey, Integer> {
+ class MappingServiceKeyConvertor implements ILispTypeConverter<MappingKey, Integer> {
}
- class MappingServiceNoMaskKeyConvertor implements ILispTypeConverter<MappingServiceNoMaskKey, Integer> {
+ class MappingServiceNoMaskKeyConvertor implements ILispTypeConverter<MappingNoMaskKey, Integer> {
}
public static LispMappingService getLispMappingService() {
if (!lastKey.equals(key)) {
sb.append(key + "\t");
}
- if (!(valueKey.equals(AbstractLispComponent.LCAF_SRCDST_SUBKEY))) {
+ if (!(valueKey.equals(DAOSubKeys.LCAF_SRCDST_SUBKEY.toString()))) {
sb.append(valueKey + "=" + value + "\t");
}
lastKey = key;
if (!lastKey.equals(key)) {
sb.append("\n" + key + "\t");
}
- if (valueKey.equals(AbstractLispComponent.LCAF_SRCDST_SUBKEY)) {
+ if (valueKey.equals(DAOSubKeys.LCAF_SRCDST_SUBKEY.toString())) {
sb.append(valueKey + "= { ");
((ILispDAO)value).getAll(innerVisitor);
sb.append("}\t");
import javax.crypto.Mac;
import javax.crypto.spec.SecretKeySpec;
-import org.opendaylight.lispflowmapping.implementation.serializer.MapNotifySerializer;
-import org.opendaylight.lispflowmapping.implementation.serializer.MapRegisterSerializer;
+import org.opendaylight.lispflowmapping.lisp.serializer.MapNotifySerializer;
+import org.opendaylight.lispflowmapping.lisp.serializer.MapRegisterSerializer;
import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.control.plane.rev150314.MapNotify;
import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.control.plane.rev150314.MapRegister;
import org.slf4j.Logger;
*/
package org.opendaylight.lispflowmapping.implementation.dao;
-import org.opendaylight.lispflowmapping.interfaces.dao.IMappingServiceKey;
+import org.opendaylight.lispflowmapping.interfaces.dao.IMappingKey;
import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.control.plane.rev150314.lispaddress.LispAddressContainer;
-public class MappingServiceKey implements IMappingServiceKey {
+public class MappingKey implements IMappingKey {
private LispAddressContainer EID;
private int mask;
- public MappingServiceKey(LispAddressContainer lispAddressContainer, int mask) {
+ public MappingKey(LispAddressContainer lispAddressContainer, int mask) {
this.EID = lispAddressContainer;
this.mask = mask;
}
return false;
if (getClass() != obj.getClass())
return false;
- MappingServiceKey other = (MappingServiceKey) obj;
+ MappingKey other = (MappingKey) obj;
if (EID == null) {
if (other.EID != null)
return false;
*/
package org.opendaylight.lispflowmapping.implementation.dao;
-import org.opendaylight.lispflowmapping.implementation.util.LispAFIConvertor;
import org.opendaylight.lispflowmapping.implementation.util.MaskUtil;
-import org.opendaylight.lispflowmapping.interfaces.dao.IMappingServiceKey;
+import org.opendaylight.lispflowmapping.interfaces.dao.IMappingKey;
+import org.opendaylight.lispflowmapping.lisp.util.LispAFIConvertor;
import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.control.plane.rev150314.LispAFIAddress;
import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.control.plane.rev150314.lispaddress.LispAddressContainer;
-public class MappingServiceKeyUtil {
+public class MappingKeyUtil {
- public static IMappingServiceKey generateMappingServiceKey(LispAddressContainer lispAddressContainer, int mask) {
+ public static IMappingKey generateMappingKey(LispAddressContainer lispAddressContainer, int mask) {
LispAFIAddress address = LispAFIConvertor.toAFI(lispAddressContainer);
if (MaskUtil.isMaskable(address)) {
LispAddressContainer normalizedAddress = LispAFIConvertor.toContainer(MaskUtil.normalize(address, mask));
- return new MappingServiceKey(normalizedAddress, mask);
+ return new MappingKey(normalizedAddress, mask);
} else {
- return new MappingServiceNoMaskKey(lispAddressContainer);
+ return new MappingNoMaskKey(lispAddressContainer);
}
}
- public static IMappingServiceKey generateMappingServiceKey(LispAFIAddress address, int mask) {
+ public static IMappingKey generateMappingKey(LispAFIAddress address, int mask) {
if (MaskUtil.isMaskable(address)) {
LispAddressContainer normalizedAddress = LispAFIConvertor.toContainer(MaskUtil.normalize(address, mask));
- return new MappingServiceKey(normalizedAddress, mask);
+ return new MappingKey(normalizedAddress, mask);
} else {
- return new MappingServiceNoMaskKey(LispAFIConvertor.toContainer(address));
+ return new MappingNoMaskKey(LispAFIConvertor.toContainer(address));
}
}
- public static IMappingServiceKey generateMappingServiceKey(LispAddressContainer lispAddressContainer) {
+ public static IMappingKey generateMappingKey(LispAddressContainer lispAddressContainer) {
LispAFIAddress address = LispAFIConvertor.toAFI(lispAddressContainer);
if (MaskUtil.isMaskable(address)) {
- return generateMappingServiceKey(lispAddressContainer, MaskUtil.getMaxMask(address));
+ return generateMappingKey(lispAddressContainer, MaskUtil.getMaxMask(address));
} else
- return generateMappingServiceKey(lispAddressContainer, 0);
+ return generateMappingKey(lispAddressContainer, 0);
}
}
*/
package org.opendaylight.lispflowmapping.implementation.dao;
-import org.opendaylight.lispflowmapping.implementation.util.LispAFIConvertor;
import org.opendaylight.lispflowmapping.implementation.util.MaskUtil;
-import org.opendaylight.lispflowmapping.interfaces.dao.IMappingServiceKey;
+import org.opendaylight.lispflowmapping.interfaces.dao.IMappingKey;
+import org.opendaylight.lispflowmapping.lisp.util.LispAFIConvertor;
import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.control.plane.rev150314.LispAFIAddress;
import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.control.plane.rev150314.lispaddress.LispAddressContainer;
-public class MappingServiceNoMaskKey implements IMappingServiceKey {
+public class MappingNoMaskKey implements IMappingKey {
private LispAddressContainer EID;
- public MappingServiceNoMaskKey(LispAddressContainer lispAddressContainer) {
+ public MappingNoMaskKey(LispAddressContainer lispAddressContainer) {
this.EID = lispAddressContainer;
}
return false;
if (getClass() != obj.getClass())
return false;
- MappingServiceNoMaskKey other = (MappingServiceNoMaskKey) obj;
+ MappingNoMaskKey other = (MappingNoMaskKey) obj;
if (EID == null) {
if (other.EID != null)
return false;
*/
package org.opendaylight.lispflowmapping.implementation.lisp;
-import java.util.Set;
-import org.opendaylight.lispflowmapping.implementation.dao.MappingServiceKeyUtil;
-import org.opendaylight.lispflowmapping.implementation.util.LispAFIConvertor;
-import org.opendaylight.lispflowmapping.implementation.util.MaskUtil;
-import org.opendaylight.lispflowmapping.inmemorydb.HashMapDb;
import org.opendaylight.lispflowmapping.interfaces.dao.ILispDAO;
-import org.opendaylight.lispflowmapping.interfaces.dao.IMappingServiceKey;
-import org.opendaylight.lispflowmapping.interfaces.dao.MappingEntry;
-import org.opendaylight.lispflowmapping.interfaces.dao.MappingServiceSubscriberRLOC;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.control.plane.rev150314.LispAFIAddress;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.control.plane.rev150314.lispaddress.LispAddressContainer;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.control.plane.rev150314.lispaddress.lispaddresscontainer.address.LcafSourceDest;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
public abstract class AbstractLispComponent {
-
- public static final String PASSWORD_SUBKEY = "password";
- public static final String ADDRESS_SUBKEY = "address";
- public static final String SUBSCRIBERS_SUBKEY = "subscribers";
- public static final String LCAF_SRCDST_SUBKEY = "lcaf_srcdst";
public static final Logger LOG = LoggerFactory.getLogger(AbstractLispComponent.class);
protected ILispDAO dao;
public void setShouldAuthenticate(boolean shouldAuthenticate) {
this.authenticate = shouldAuthenticate;
}
-
- protected String getPassword(LispAddressContainer prefix, int maskLength) {
- if (MaskUtil.isMaskable(LispAFIConvertor.toAFI(prefix))) {
- return getPasswordForMaskable(prefix, maskLength, dao);
- } else if (prefix.getAddress() instanceof LcafSourceDest) {
- ILispDAO srcDstDao = getSrcDstInnerDao(prefix, maskLength);
- if (srcDstDao != null) {
- return getPasswordForMaskable(LispAFIConvertor.toContainer(getSrcForLcafSrcDst(prefix)),
- getSrcMaskForLcafSrcDst(prefix), srcDstDao);
- }
- return null;
- } else {
- IMappingServiceKey key = MappingServiceKeyUtil.generateMappingServiceKey(prefix, maskLength);
- Object password = dao.getSpecific(key, PASSWORD_SUBKEY);
- if (password != null && password instanceof String) {
- return (String) password;
- } else {
- LOG.warn("Failed to find password!");
- return null;
- }
- }
- }
-
- private String getPasswordForMaskable(LispAddressContainer prefix, int maskLength, ILispDAO db) {
- while (maskLength >= 0) {
- IMappingServiceKey key = MappingServiceKeyUtil.generateMappingServiceKey(prefix, maskLength);
- Object password = db.getSpecific(key, PASSWORD_SUBKEY);
- if (password != null && password instanceof String) {
- return (String) password;
- } else if (shouldIterateMask()) {
- maskLength -= 1;
- } else {
- LOG.warn("Failed to find password!");
- return null;
- }
- }
- return null;
- }
-
- @SuppressWarnings("unchecked")
- protected Set<MappingServiceSubscriberRLOC> getSubscribers(LispAddressContainer prefix, int maskLength) {
- Object subscribers;
- if (prefix.getAddress() instanceof LcafSourceDest) {
- IMappingServiceKey srcKey = MappingServiceKeyUtil.generateMappingServiceKey(getSrcForLcafSrcDst(prefix),
- getSrcMaskForLcafSrcDst(prefix));
- ILispDAO srcDstDao = getSrcDstInnerDao(prefix, maskLength);
- subscribers = srcDstDao.getSpecific(srcKey, SUBSCRIBERS_SUBKEY);
- } else {
- IMappingServiceKey key = MappingServiceKeyUtil.generateMappingServiceKey(prefix, maskLength);
- subscribers = dao.getSpecific(key, SUBSCRIBERS_SUBKEY);
- }
-
- if (subscribers != null && subscribers instanceof Set<?>) {
- return (Set<MappingServiceSubscriberRLOC>) subscribers;
- }
- return null;
- }
-
- protected static LispAFIAddress getSrcForLcafSrcDst(LispAddressContainer container) {
- return LispAFIConvertor.toAFIfromPrimitive(((LcafSourceDest) container.getAddress()).getLcafSourceDestAddr().
- getSrcAddress().getPrimitiveAddress());
- }
-
- protected static LispAFIAddress getDstForLcafSrcDst(LispAddressContainer container) {
- return LispAFIConvertor.toAFIfromPrimitive(((LcafSourceDest) container.getAddress()).getLcafSourceDestAddr().
- getDstAddress().getPrimitiveAddress());
- }
-
- protected static short getSrcMaskForLcafSrcDst(LispAddressContainer container) {
- return ((LcafSourceDest) container.getAddress()).getLcafSourceDestAddr().getSrcMaskLength();
- }
-
- protected static short getDstMaskForLcafSrcDst(LispAddressContainer container) {
- return ((LcafSourceDest) container.getAddress()).getLcafSourceDestAddr().getDstMaskLength();
- }
-
- // 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.
- protected ILispDAO getOrInstantiateSrcDstInnerDao(LispAddressContainer address, int maskLen) {
- IMappingServiceKey dstKey = MappingServiceKeyUtil.generateMappingServiceKey(getDstForLcafSrcDst(address),
- getDstMaskForLcafSrcDst(address));
- ILispDAO srcDstDao = (ILispDAO) dao.getSpecific(dstKey, LCAF_SRCDST_SUBKEY);
- if (srcDstDao == null) {
- srcDstDao = new HashMapDb();
- dao.put(dstKey, new MappingEntry<>(LCAF_SRCDST_SUBKEY, srcDstDao));
- }
- return srcDstDao;
- }
-
- // 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 null if it doesn't exist.
- protected ILispDAO getSrcDstInnerDao(LispAddressContainer address, int maskLen) {
- IMappingServiceKey dstKey = MappingServiceKeyUtil.generateMappingServiceKey(getDstForLcafSrcDst(address),
- getDstMaskForLcafSrcDst(address));
- return (ILispDAO) dao.getSpecific(dstKey, LCAF_SRCDST_SUBKEY);
- }
}
import org.apache.commons.lang3.exception.ExceptionUtils;
import org.opendaylight.lispflowmapping.implementation.config.ConfigIni;
-import org.opendaylight.lispflowmapping.implementation.dao.MappingServiceKeyUtil;
import org.opendaylight.lispflowmapping.implementation.util.DAOMappingUtil;
-import org.opendaylight.lispflowmapping.implementation.util.LispAFIConvertor;
import org.opendaylight.lispflowmapping.interfaces.dao.ILispDAO;
-import org.opendaylight.lispflowmapping.interfaces.dao.IMappingServiceKey;
-import org.opendaylight.lispflowmapping.interfaces.dao.MappingEntry;
-import org.opendaylight.lispflowmapping.interfaces.dao.MappingServiceRLOCGroup;
-import org.opendaylight.lispflowmapping.interfaces.dao.MappingServiceSubscriberRLOC;
+import org.opendaylight.lispflowmapping.interfaces.dao.IMappingKey;
+import org.opendaylight.lispflowmapping.interfaces.dao.RLOCGroup;
+import org.opendaylight.lispflowmapping.interfaces.dao.SubscriberRLOC;
import org.opendaylight.lispflowmapping.interfaces.lisp.IMapRequestResultHandler;
import org.opendaylight.lispflowmapping.interfaces.lisp.IMapResolverAsync;
+import org.opendaylight.lispflowmapping.lisp.util.LispAFIConvertor;
import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.control.plane.rev150314.EidToLocatorRecord.Action;
import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.control.plane.rev150314.LcafTrafficEngineeringAddress;
import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.control.plane.rev150314.LispAFIAddress;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
+import com.google.common.base.Preconditions;
import com.google.common.collect.Sets;
public class MapResolver extends AbstractLispComponent implements IMapResolverAsync {
}
public void handleMapRequest(MapRequest request, boolean smr, IMapRequestResultHandler callback) {
- if (dao == null) {
- LOG.warn("handleMapRequest called while dao is uninitialized");
- return;
- }
+ Preconditions.checkNotNull(dao);
LispAddressContainer srcEid = null;
LispAFIAddress srcEidAfi = null;
builder.setEidToLocatorRecord(new ArrayList<EidToLocatorRecord>());
for (EidRecord eid : request.getEidRecord()) {
EidToLocatorRecordBuilder recordBuilder = new EidToLocatorRecordBuilder();
- Entry<IMappingServiceKey, List<MappingServiceRLOCGroup>> mapping =
+ Entry<IMappingKey, List<RLOCGroup>> mapping =
DAOMappingUtil.getMapping(srcEidAfi, eid, dao);
recordBuilder.setRecordTtl(0);
recordBuilder.setAction(Action.NoAction);
recordBuilder.setMaskLength((short) mapping.getKey().getMask());
recordBuilder.setLispAddressContainer(mapping.getKey().getEID());
recordBuilder.setLocatorRecord(new ArrayList<LocatorRecord>());
- List<MappingServiceRLOCGroup> locators = mapping.getValue();
+ List<RLOCGroup> locators = mapping.getValue();
if (locators != null && locators.size() > 0) {
List<ItrRloc> itrRlocs = request.getItrRloc();
addLocatorGroups(recordBuilder, locators, itrRlocs);
- if (srcEid != null && !(srcEid.getAddress() instanceof No) && itrRlocs != null && itrRlocs.size() > 0) {
+ if (srcEid != null && !(srcEid.getAddress() instanceof No) && itrRlocs != null
+ && itrRlocs.size() > 0) {
LispAddressContainer itrRloc = itrRlocs.get(0).getLispAddressContainer();
- MappingServiceSubscriberRLOC subscriberRloc = new MappingServiceSubscriberRLOC(itrRloc, srcEid);
- Set<MappingServiceSubscriberRLOC> subscribers = getSubscribers(mapping.getKey().getEID(), mapping.getKey().getMask());
+ SubscriberRLOC subscriberRloc = new SubscriberRLOC(itrRloc, srcEid);
+ Set<SubscriberRLOC> subscribers = DAOMappingUtil.getSubscribers(mapping.getKey().getEID(),
+ mapping.getKey().getMask(), dao);
if (subscribers == null) {
subscribers = Sets.newConcurrentHashSet();
} else if (subscribers.contains(subscriberRloc)) {
- /*
- * If there is an entry already for this
- * subscriberRloc, remove it, so that it gets the
- * new timestamp
- */
+ // If there is an entry already for this subscriberRloc, remove it, so that it gets the new
+ // timestamp
subscribers.remove(subscriberRloc);
}
if (smr) {
- IMappingServiceKey key = MappingServiceKeyUtil.generateMappingServiceKey(mapping.getKey().getEID(),
- mapping.getKey().getMask());
LOG.trace("Adding new subscriber: " + subscriberRloc.toString());
subscribers.add(subscriberRloc);
- dao.put(key, new MappingEntry<Set<MappingServiceSubscriberRLOC>>(SUBSCRIBERS_SUBKEY, subscribers));
+ DAOMappingUtil.addSubscribers(mapping.getKey().getEID(), mapping.getKey().getMask(),
+ subscribers, dao);
}
}
} else {
recordBuilder.setAction(Action.NativelyForward);
- if (shouldAuthenticate() && getPassword(eid.getLispAddressContainer(), eid.getMask()) != null) {
+ if (shouldAuthenticate() && DAOMappingUtil.getPassword(eid.getLispAddressContainer(), eid.getMask(),
+ dao, shouldIterateMask()) != null) {
recordBuilder.setRecordTtl(TTL_RLOC_TIMED_OUT);
} else {
recordBuilder.setRecordTtl(TTL_NO_RLOC_KNOWN);
}
builder.getEidToLocatorRecord().add(recordBuilder.build());
}
-
callback.handleMapReply(builder.build());
-
}
- private void addLocatorGroups(EidToLocatorRecordBuilder recordBuilder, List<MappingServiceRLOCGroup> rlocs, List<ItrRloc> itrRlocs) {
- for (MappingServiceRLOCGroup rloc : rlocs) {
+ private void addLocatorGroups(EidToLocatorRecordBuilder recordBuilder, List<RLOCGroup> rlocs,
+ List<ItrRloc> itrRlocs) {
+ for (RLOCGroup rloc : rlocs) {
addLocators(recordBuilder, rloc, itrRlocs);
recordBuilder.setRecordTtl(rloc.getTtl());
}
}
- private void addLocators(EidToLocatorRecordBuilder recordBuilder, MappingServiceRLOCGroup locatorObject, List<ItrRloc> itrRlocs) {
- if (locatorObject == null) {
- return;
- }
+ private void addLocators(EidToLocatorRecordBuilder recordBuilder, RLOCGroup locatorObject,
+ List<ItrRloc> itrRlocs) {
+ Preconditions.checkNotNull(locatorObject);
recordBuilder.setAction(locatorObject.getAction());
recordBuilder.setAuthoritative(locatorObject.isAuthoritative());
for (LocatorRecord record : locatorObject.getRecords()) {
LispAddressContainer container = record.getLispAddressContainer();
- // 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)) || elpPolicy.equalsIgnoreCase("default") || itrRlocs == null) {
+ // 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))
+ || 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())
+ 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());
continue;
}
- LcafTrafficEngineeringAddress teAddress = ((LcafTrafficEngineering) container.getAddress()).getLcafTrafficEngineeringAddr();
+ LcafTrafficEngineeringAddress teAddress = ((LcafTrafficEngineering) container.getAddress())
+ .getLcafTrafficEngineeringAddr();
LispAddressContainer nextHop = getNextELPHop(teAddress, itrRlocs);
if (nextHop != null) {
java.lang.Short priority = record.getPriority();
if (elpPolicy.equalsIgnoreCase("both")) {
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());
+ 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());
// 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
}
// Build and add the simple RLOC
recordBuilder.getLocatorRecord().add(
- new LocatorRecordBuilder().setLocalLocator(record.isLocalLocator()).setRlocProbed(record.isRlocProbed())
- .setWeight(record.getWeight()).setPriority(priority).setMulticastWeight(record.getMulticastWeight())
- .setMulticastPriority(record.getMulticastPriority()).setRouted(record.isRouted())
- .setLispAddressContainer(nextHop).setName(record.getName()).build());
+ new LocatorRecordBuilder().setLocalLocator(record.isLocalLocator())
+ .setRlocProbed(record.isRlocProbed()).setWeight(record.getWeight())
+ .setPriority(priority).setMulticastWeight(record.getMulticastWeight())
+ .setMulticastPriority(record.getMulticastPriority()).setRouted(record.isRouted())
+ .setLispAddressContainer(nextHop).setName(record.getName()).build());
}
}
} catch (ClassCastException cce) {
if (hops != null && hops.size() > 0) {
// By default we return the first hop
- nextHop = LispAFIConvertor.toContainer(LispAFIConvertor.toAFIfromPrimitive(hops.get(0).getHop().getPrimitiveAddress()));
+ nextHop = LispAFIConvertor.toContainer(LispAFIConvertor.toAFIfromPrimitive(hops.get(0).getHop()
+ .getPrimitiveAddress()));
for (Hops hop : hops) {
- LispAddressContainer hopContainer = LispAFIConvertor.toContainer(LispAFIConvertor.toAFIfromPrimitive(hop.getHop().getPrimitiveAddress()));
+ LispAddressContainer hopContainer = LispAFIConvertor.toContainer(LispAFIConvertor
+ .toAFIfromPrimitive(hop.getHop().getPrimitiveAddress()));
for (ItrRloc itrRloc : itrRlocs) {
if (itrRloc.getLispAddressContainer().equals(hopContainer)) {
int i = hops.indexOf(hop);
if (i < hops.size() - 1) {
- nextHop = LispAFIConvertor.toContainer(LispAFIConvertor.toAFIfromPrimitive(hops.get(i+1).getHop().getPrimitiveAddress()));
+ nextHop = LispAFIConvertor.toContainer(LispAFIConvertor.toAFIfromPrimitive(hops.get(i + 1)
+ .getHop().getPrimitiveAddress()));
return nextHop;
}
}
return nextHop;
}
-}
+}
\ No newline at end of file
import java.net.SocketException;
import java.util.ArrayList;
import java.util.Enumeration;
-import java.util.HashMap;
-import java.util.List;
-import java.util.Map;
-import java.util.Random;
-import java.util.Map.Entry;
import java.util.Set;
import org.apache.commons.lang3.BooleanUtils;
import org.apache.commons.lang3.exception.ExceptionUtils;
import org.opendaylight.lispflowmapping.implementation.authentication.LispAuthenticationUtil;
import org.opendaylight.lispflowmapping.implementation.config.ConfigIni;
-import org.opendaylight.lispflowmapping.implementation.dao.MappingServiceKeyUtil;
import org.opendaylight.lispflowmapping.implementation.util.DAOMappingUtil;
-import org.opendaylight.lispflowmapping.implementation.util.LispAFIConvertor;
-import org.opendaylight.lispflowmapping.implementation.util.MapNotifyBuilderHelper;
-import org.opendaylight.lispflowmapping.inmemorydb.HashMapDb;
import org.opendaylight.lispflowmapping.implementation.util.MaskUtil;
import org.opendaylight.lispflowmapping.interfaces.dao.ILispDAO;
-import org.opendaylight.lispflowmapping.interfaces.dao.IMappingServiceKey;
-import org.opendaylight.lispflowmapping.interfaces.dao.MappingEntry;
-import org.opendaylight.lispflowmapping.interfaces.dao.MappingServiceRLOCGroup;
-import org.opendaylight.lispflowmapping.interfaces.dao.MappingServiceSubscriberRLOC;
+import org.opendaylight.lispflowmapping.interfaces.dao.SubscriberRLOC;
import org.opendaylight.lispflowmapping.interfaces.lisp.IMapNotifyHandler;
import org.opendaylight.lispflowmapping.interfaces.lisp.IMapServerAsync;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.control.plane.rev150314.LispAFIAddress;
+import org.opendaylight.lispflowmapping.lisp.util.LispAFIConvertor;
+import org.opendaylight.lispflowmapping.lisp.util.MapNotifyBuilderHelper;
+import org.opendaylight.lispflowmapping.lisp.util.MapRequestUtil;
import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.control.plane.rev150314.MapRegister;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.control.plane.rev150314.eidrecords.EidRecord;
import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.control.plane.rev150314.eidrecords.EidRecordBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.control.plane.rev150314.eidtolocatorrecords.EidToLocatorRecord;
import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.control.plane.rev150314.eidtolocatorrecords.EidToLocatorRecordBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.control.plane.rev150314.lispaddress.LispAddressContainer;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.control.plane.rev150314.lispaddress.lispaddresscontainer.Address;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.control.plane.rev150314.lispaddress.lispaddresscontainer.address.LcafKeyValue;
import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.control.plane.rev150314.lispaddress.lispaddresscontainer.address.LcafSourceDest;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.control.plane.rev150314.lispsimpleaddress.primitiveaddress.DistinguishedName;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.control.plane.rev150314.locatorrecords.LocatorRecord;
import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.control.plane.rev150314.mapnotifymessage.MapNotifyBuilder;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.control.plane.rev150314.maprequest.ItrRloc;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.control.plane.rev150314.maprequest.ItrRlocBuilder;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.control.plane.rev150314.maprequest.SourceEidBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.control.plane.rev150314.maprequestnotification.MapRequestBuilder;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
return null;
}
- private static MapRequestBuilder buildSMR(LispAddressContainer srcEid) {
- MapRequestBuilder builder = new MapRequestBuilder();
- builder.setAuthoritative(false);
- builder.setMapDataPresent(false);
- builder.setPitr(false);
- builder.setProbe(false);
- builder.setSmr(true);
- builder.setSmrInvoked(false);
-
- builder.setSourceEid(new SourceEidBuilder().setLispAddressContainer(srcEid).build());
- builder.setItrRloc(new ArrayList<ItrRloc>());
- builder.getItrRloc().add(new ItrRlocBuilder().setLispAddressContainer(LispAFIConvertor.toContainer(getLocalAddress())).build());
- builder.setMapReply(null);
- builder.setNonce(new Random().nextLong());
-
- return builder;
- }
-
public void handleMapRegister(MapRegister mapRegister, boolean smr, IMapNotifyHandler callback) {
if (dao == null) {
LOG.warn("handleMapRegister called while dao is uninitialized");
String password = null;
for (EidToLocatorRecord eidRecord : mapRegister.getEidToLocatorRecord()) {
if (shouldAuthenticate()) {
- password = getPassword(eidRecord.getLispAddressContainer(), eidRecord.getMaskLength());
+ password = DAOMappingUtil.getPassword(eidRecord.getLispAddressContainer(),
+ eidRecord.getMaskLength(), dao, shouldIterateMask());
if (!LispAuthenticationUtil.validate(mapRegister, password)) {
LOG.warn("Authentication failed");
failed = true;
break;
}
}
- boolean mappingChanged = saveRlocs(eidRecord, smr);
+ boolean mappingChanged = DAOMappingUtil.saveRlocs(eidRecord, smr, dao, shouldIterateMask(),
+ shouldOverwrite());
if (smr && mappingChanged) {
- sendSmrs(eidRecord, callback);
+ Set<SubscriberRLOC> subscribers = DAOMappingUtil.getSubscribers(
+ eidRecord.getLispAddressContainer(), eidRecord.getMaskLength(), dao);
+ sendSmrs(eidRecord, subscribers, callback);
}
}
if (!failed) {
LOG.trace("MapRegister wants MapNotify");
MapNotifyBuilderHelper.setFromMapRegister(builder, mapRegister);
if (shouldAuthenticate()) {
- builder.setAuthenticationData(LispAuthenticationUtil.createAuthenticationData(builder.build(), password));
+ builder.setAuthenticationData(LispAuthenticationUtil.createAuthenticationData(builder.build(),
+ password));
}
callback.handleMapNotify(builder.build());
}
}
}
- public boolean saveRlocs(EidToLocatorRecord eidRecord, boolean checkForChanges) {
- Map<String, MappingServiceRLOCGroup> rlocGroups = new HashMap<String, MappingServiceRLOCGroup>();
- if (eidRecord.getLocatorRecord() != null) {
- for (LocatorRecord locatorRecord : eidRecord.getLocatorRecord()) {
- String subkey = getAddressKey(locatorRecord.getLispAddressContainer().getAddress());
- if (!rlocGroups.containsKey(subkey)) {
- rlocGroups.put(subkey, new MappingServiceRLOCGroup(eidRecord.getRecordTtl(), eidRecord.getAction(), eidRecord.isAuthoritative()));
- }
- rlocGroups.get(subkey).addRecord(locatorRecord);
- }
- } else {
- rlocGroups.put(ADDRESS_SUBKEY, new MappingServiceRLOCGroup(eidRecord.getRecordTtl(), eidRecord.getAction(), eidRecord.isAuthoritative()));
- }
- List<MappingEntry<MappingServiceRLOCGroup>> entries = new ArrayList<>();
- for (String subkey : rlocGroups.keySet()) {
- entries.add(new MappingEntry<>(subkey, rlocGroups.get(subkey)));
- }
-
- if (eidRecord.getLispAddressContainer().getAddress() instanceof LcafSourceDest) {
- Entry<IMappingServiceKey, List<MappingServiceRLOCGroup>> oldMapping= null, newMapping = null;
- LispAFIAddress srcAddr = getSrcForLcafSrcDst(eidRecord.getLispAddressContainer());
- LispAFIAddress dstAddr = getDstForLcafSrcDst(eidRecord.getLispAddressContainer());
- short srcMask = getSrcMaskForLcafSrcDst(eidRecord.getLispAddressContainer());
- short dstMask = getDstMaskForLcafSrcDst(eidRecord.getLispAddressContainer());
-
- if (checkForChanges) {
- oldMapping = DAOMappingUtil.getMappingExact(srcAddr, dstAddr, srcMask, dstMask, dao);
- }
- IMappingServiceKey dstKey = MappingServiceKeyUtil.generateMappingServiceKey(dstAddr, dstMask);
- ILispDAO srcDstDao = (ILispDAO) dao.getSpecific(dstKey, LCAF_SRCDST_SUBKEY);
- if (srcDstDao == null) {
- srcDstDao = new HashMapDb();
- dao.put(dstKey, new MappingEntry<>(LCAF_SRCDST_SUBKEY, srcDstDao));
- }
- IMappingServiceKey srcKey = MappingServiceKeyUtil.generateMappingServiceKey(srcAddr, srcMask);
- srcDstDao.put(srcKey, entries.toArray(new MappingEntry[entries.size()]));
- if (checkForChanges) {
- newMapping = DAOMappingUtil.getMappingExact(srcAddr, dstAddr, srcMask, dstMask, dao);
- return (newMapping.getValue() == null) ? oldMapping.getValue() != null :
- !newMapping.getValue().equals(oldMapping.getValue());
- }
- } else {
- List<MappingServiceRLOCGroup> oldLocators = null, newLocators = null;
- if (checkForChanges) {
- oldLocators = DAOMappingUtil.getLocatorsByEidToLocatorRecord(eidRecord, dao, shouldIterateMask());
- }
- IMappingServiceKey key = MappingServiceKeyUtil.generateMappingServiceKey(eidRecord.getLispAddressContainer(),
- eidRecord.getMaskLength());
- dao.put(key, entries.toArray(new MappingEntry[entries.size()]));
- if (checkForChanges) {
- newLocators = DAOMappingUtil.getLocatorsByEidToLocatorRecord(eidRecord, dao, shouldIterateMask());
- return (newLocators == null) ? oldLocators != null : !newLocators.equals(oldLocators);
- }
- }
- return false;
- }
-
- private String getAddressKey(Address address) {
- if (address instanceof LcafKeyValue) {
- LcafKeyValue keyVal = (LcafKeyValue) address;
- if (keyVal.getLcafKeyValueAddressAddr().getKey().getPrimitiveAddress() instanceof DistinguishedName) {
- return ((DistinguishedName) keyVal.getLcafKeyValueAddressAddr().getKey().getPrimitiveAddress()).getDistinguishedNameAddress().getDistinguishedName();
- }
- }
- if (shouldOverwrite()) {
- return ADDRESS_SUBKEY;
- } else {
- return String.valueOf(address.hashCode());
- }
- }
-
public String getAuthenticationKey(LispAddressContainer address, int maskLen) {
- return getPassword(address, maskLen);
+ return DAOMappingUtil.getPassword(address, maskLen, dao, shouldIterateMask());
}
public void removeAuthenticationKey(LispAddressContainer address, int maskLen) {
- if (address.getAddress() instanceof LcafSourceDest) {
- ILispDAO srcDstDao = getSrcDstInnerDao(address, maskLen);
- if (srcDstDao != null) {
- IMappingServiceKey srcKey = MappingServiceKeyUtil.generateMappingServiceKey(getSrcForLcafSrcDst(address),
- getSrcMaskForLcafSrcDst(address));
- srcDstDao.removeSpecific(srcKey, PASSWORD_SUBKEY);
- }
- } else {
- IMappingServiceKey key = MappingServiceKeyUtil.generateMappingServiceKey(address, maskLen);
- dao.removeSpecific(key, PASSWORD_SUBKEY);
- }
- }
-
- public void addAuthenticationKey(LispAddressContainer address, int maskLen, String key) {
- IMappingServiceKey mappingServiceKey = MappingServiceKeyUtil.generateMappingServiceKey(address, maskLen);
- if (address.getAddress() instanceof LcafSourceDest) {
- IMappingServiceKey srcKey = MappingServiceKeyUtil.generateMappingServiceKey(getSrcForLcafSrcDst(address),
- getSrcMaskForLcafSrcDst(address));
- ILispDAO srcDstDao = getOrInstantiateSrcDstInnerDao(address, maskLen);
- srcDstDao.put(srcKey, new MappingEntry<String>(PASSWORD_SUBKEY, key));
- } else {
- dao.put(mappingServiceKey, new MappingEntry<String>(PASSWORD_SUBKEY, key));
- }
+ DAOMappingUtil.removeAuthenticationKey(address, maskLen, dao);
}
public void removeMapping(LispAddressContainer address, int maskLen, boolean smr, IMapNotifyHandler callback) {
- Entry<IMappingServiceKey, List<MappingServiceRLOCGroup>> mapping;
- ILispDAO db;
- if (address.getAddress() instanceof LcafSourceDest) {
- db = getSrcDstInnerDao(address, maskLen);
- LispAFIAddress srcAddr = getSrcForLcafSrcDst(address);
- short srcMask = getSrcMaskForLcafSrcDst(address);
- mapping = DAOMappingUtil.getMappingForEid(srcAddr, srcMask, db);
- } else {
- db = dao;
- mapping = DAOMappingUtil.getMappingForEid(LispAFIConvertor.toAFI(address), maskLen, db);
- }
if (smr) {
// mapping is removed before first SMR is sent to avoid inconsistent replies
- removeMappingRlocs(mapping, db);
+ DAOMappingUtil.removeMapping(address, maskLen, dao, shouldOverwrite());
+ Set<SubscriberRLOC> subscribers = DAOMappingUtil.getSubscribers(address, maskLen, dao);
sendSmrs(new EidToLocatorRecordBuilder().setLispAddressContainer(address).
- setMaskLength((short) maskLen).build(), callback);
- db.removeSpecific(mapping.getKey(), SUBSCRIBERS_SUBKEY);
+ setMaskLength((short) maskLen).build(), subscribers, callback);
+ DAOMappingUtil.removeSubscribers(address, maskLen, dao, shouldOverwrite());
} else {
- removeMappingRlocs(mapping, db);
- db.removeSpecific(mapping.getKey(), SUBSCRIBERS_SUBKEY);
+ DAOMappingUtil.removeMapping(address, maskLen, dao, shouldOverwrite());
+ DAOMappingUtil.removeSubscribers(address, maskLen, dao, shouldOverwrite());
}
}
- private void removeMappingRlocs(Entry<IMappingServiceKey, List<MappingServiceRLOCGroup>> mapping, ILispDAO db) {
- if (mapping == null || mapping.getValue() == null) {
- return;
- }
- for (MappingServiceRLOCGroup group : mapping.getValue()) {
- for (LocatorRecord record : group.getRecords()) {
- db.removeSpecific(mapping.getKey(), getAddressKey(record.getLispAddressContainer().getAddress()));
- }
- }
- }
-
- private void sendSmrs(EidToLocatorRecord record, IMapNotifyHandler callback) {
+ private void sendSmrs(EidToLocatorRecord record, Set<SubscriberRLOC> subscribers, IMapNotifyHandler callback) {
LispAddressContainer eid = record.getLispAddressContainer();
- Set<MappingServiceSubscriberRLOC> subscribers;
-
- subscribers = getSubscribers(eid, record.getMaskLength());
handleSmr(record, subscribers, callback);
// For SrcDst LCAF also send SMRs to Dst prefix
if (eid.getAddress() instanceof LcafSourceDest) {
- LispAddressContainer dstAddr = LispAFIConvertor.toContainer(getDstForLcafSrcDst(eid));
- short dstMask = getDstMaskForLcafSrcDst(eid);
- subscribers = getSubscribers(dstAddr, dstMask);
+ LispAddressContainer dstAddr = LispAFIConvertor.toContainer(DAOMappingUtil.getDstForLcafSrcDst(eid));
+ short dstMask = DAOMappingUtil.getDstMaskForLcafSrcDst(eid);
+ subscribers = DAOMappingUtil.getSubscribers(dstAddr, dstMask, dao);
EidToLocatorRecord newRecord = new EidToLocatorRecordBuilder().setAction(record.getAction()).
setAuthoritative(record.isAuthoritative()).setLocatorRecord(record.getLocatorRecord()).
setMapVersion(record.getMapVersion()).setRecordTtl(record.getRecordTtl()).
}
}
- private void handleSmr(EidToLocatorRecord record, Set<MappingServiceSubscriberRLOC> subscribers,
- IMapNotifyHandler callback) {
+ private void handleSmr(EidToLocatorRecord record, Set<SubscriberRLOC> subscribers, IMapNotifyHandler callback) {
if (subscribers == null) {
return;
}
- MapRequestBuilder mrb = buildSMR(record.getLispAddressContainer());
+ MapRequestBuilder mrb = MapRequestUtil.prepareSMR(record.getLispAddressContainer(),
+ LispAFIConvertor.toContainer(getLocalAddress()));
LOG.trace("Built SMR packet: " + mrb.build().toString());
- for (MappingServiceSubscriberRLOC subscriber : subscribers) {
+ for (SubscriberRLOC subscriber : subscribers) {
if (subscriber.timedOut()) {
LOG.trace("Lazy removing expired subscriber entry " + subscriber.toString());
subscribers.remove(subscriber);
} else {
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<org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.control.plane.rev150314.eidrecords.EidRecord>());
+ // 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());
}
}
}
- IMappingServiceKey key = MappingServiceKeyUtil.generateMappingServiceKey(record.getLispAddressContainer(),
- record.getMaskLength());
- dao.put(key, new MappingEntry<Set<MappingServiceSubscriberRLOC>>(SUBSCRIBERS_SUBKEY, subscribers));
+ DAOMappingUtil.addSubscribers(record.getLispAddressContainer(), record.getMaskLength(), subscribers, dao);
}
public boolean shouldOverwrite() {
this.overwrite = overwrite;
}
+ @Override
+ public void addAuthenticationKey(LispAddressContainer address, int maskLen, String key) {
+ DAOMappingUtil.addAuthenticationKey(address, maskLen, key, dao);
+ }
+
}
import org.opendaylight.controller.md.sal.common.api.data.ReadFailedException;
import org.opendaylight.controller.md.sal.common.api.data.TransactionCommitFailedException;
import org.opendaylight.lispflowmapping.implementation.util.InstanceIdentifierUtil;
-import org.opendaylight.lispflowmapping.implementation.util.LispAddressStringifier;
+import org.opendaylight.lispflowmapping.lisp.util.LispAddressStringifier;
import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.mapping.database.rev150314.MappingDatabase;
import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.mapping.database.rev150314.db.instance.AuthenticationKey;
import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.mapping.database.rev150314.db.instance.Mapping;
import org.opendaylight.controller.md.sal.common.api.data.AsyncDataChangeEvent;
import org.opendaylight.lispflowmapping.implementation.LispMappingService;
import org.opendaylight.lispflowmapping.implementation.config.ConfigIni;
-import org.opendaylight.lispflowmapping.implementation.util.MapServerMapResolverUtil;
+import org.opendaylight.lispflowmapping.lisp.util.MapServerMapResolverUtil;
import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.control.plane.rev150314.MapRegister;
import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.mapping.database.rev150314.MappingDatabase;
import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.mapping.database.rev150314.MappingOrigin;
import java.util.AbstractMap;
import java.util.ArrayList;
+import java.util.HashMap;
import java.util.List;
import java.util.Map;
+import java.util.Set;
import java.util.Map.Entry;
-import org.opendaylight.lispflowmapping.implementation.dao.MappingServiceKeyUtil;
+import org.opendaylight.lispflowmapping.implementation.dao.MappingKeyUtil;
import org.opendaylight.lispflowmapping.interfaces.dao.ILispDAO;
-import org.opendaylight.lispflowmapping.interfaces.dao.IMappingServiceKey;
-import org.opendaylight.lispflowmapping.interfaces.dao.MappingServiceRLOCGroup;
+import org.opendaylight.lispflowmapping.interfaces.dao.IMappingKey;
+import org.opendaylight.lispflowmapping.interfaces.dao.MappingEntry;
+import org.opendaylight.lispflowmapping.interfaces.dao.RLOCGroup;
+import org.opendaylight.lispflowmapping.interfaces.dao.SubscriberRLOC;
import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.control.plane.rev150314.LispAFIAddress;
import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.control.plane.rev150314.eidrecords.EidRecord;
import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.control.plane.rev150314.eidtolocatorrecords.EidToLocatorRecord;
import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.control.plane.rev150314.lcafsourcedestaddress.DstAddressBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.control.plane.rev150314.lcafsourcedestaddress.SrcAddressBuilder;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.control.plane.rev150314.lispaddress.LispAddressContainer;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.control.plane.rev150314.lispaddress.lispaddresscontainer.Address;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.control.plane.rev150314.lispaddress.lispaddresscontainer.address.LcafKeyValue;
import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.control.plane.rev150314.lispaddress.lispaddresscontainer.address.LcafSourceDest;
import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.control.plane.rev150314.lispaddress.lispaddresscontainer.address.lcafsourcedest.LcafSourceDestAddr;
import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.control.plane.rev150314.lispaddress.lispaddresscontainer.address.lcafsourcedest.LcafSourceDestAddrBuilder;
-import org.opendaylight.lispflowmapping.implementation.lisp.AbstractLispComponent;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.control.plane.rev150314.lispsimpleaddress.primitiveaddress.DistinguishedName;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.control.plane.rev150314.locatorrecords.LocatorRecord;
+import org.opendaylight.lispflowmapping.inmemorydb.HashMapDb;
+import org.opendaylight.lispflowmapping.lisp.util.LispAFIConvertor;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
public class DAOMappingUtil {
+ private static final Logger LOG = LoggerFactory.getLogger(DAOMappingUtil.class);
- public static List<MappingServiceRLOCGroup> getLocatorsByEidRecord(EidRecord eid, ILispDAO dao, boolean iterateMask) {
- IMappingServiceKey key = MappingServiceKeyUtil.generateMappingServiceKey(eid.getLispAddressContainer(), eid.getMask());
+ public static List<RLOCGroup> getLocatorsByEidRecord(EidRecord eid, ILispDAO dao, boolean iterateMask) {
+ IMappingKey key = MappingKeyUtil.generateMappingKey(eid.getLispAddressContainer(), eid.getMask());
return getLocators(key, dao, iterateMask);
}
- public static Object getLocatorsSpecificByEidRecord(EidRecord eid, ILispDAO dao, String subkey, boolean iterateMask) {
- IMappingServiceKey key = MappingServiceKeyUtil.generateMappingServiceKey(eid.getLispAddressContainer(), eid.getMask());
+ public static Object getLocatorsSpecificByEidRecord(EidRecord eid, ILispDAO dao, String subkey,
+ boolean iterateMask) {
+ IMappingKey key = MappingKeyUtil.generateMappingKey(eid.getLispAddressContainer(), eid.getMask());
return getLocatorsSpecific(key, dao, subkey, iterateMask);
}
- public static List<MappingServiceRLOCGroup> getLocatorsByEidToLocatorRecord(EidToLocatorRecord eid, ILispDAO dao, boolean iterateMask) {
- IMappingServiceKey key = MappingServiceKeyUtil.generateMappingServiceKey(eid.getLispAddressContainer(), eid.getMaskLength());
+ public static List<RLOCGroup> getLocatorsByEidToLocatorRecord(EidToLocatorRecord eid, ILispDAO dao,
+ boolean iterateMask) {
+ IMappingKey key = MappingKeyUtil.generateMappingKey(eid.getLispAddressContainer(), eid.getMaskLength());
return getLocators(key, dao, iterateMask);
}
- public static Object getLocatorsSpecificByEidtoLocatorRecord(EidToLocatorRecord eid, ILispDAO dao, String subkey, boolean iterateMask) {
- IMappingServiceKey key = MappingServiceKeyUtil.generateMappingServiceKey(eid.getLispAddressContainer(), eid.getMaskLength());
+ public static Object getLocatorsSpecificByEidtoLocatorRecord(EidToLocatorRecord eid, ILispDAO dao, String subkey,
+ boolean iterateMask) {
+ IMappingKey key = MappingKeyUtil.generateMappingKey(eid.getLispAddressContainer(), eid.getMaskLength());
return getLocatorsSpecific(key, dao, subkey, iterateMask);
}
- public static List<MappingServiceRLOCGroup> getLocators(IMappingServiceKey key, ILispDAO dao, boolean iterateMask) {
+ public static List<RLOCGroup> getLocators(IMappingKey key, ILispDAO dao, boolean iterateMask) {
Map<String, ?> locators = dao.get(key);
- List<MappingServiceRLOCGroup> result = aggregateLocators(locators);
+ List<RLOCGroup> result = aggregateLocators(locators);
LispAFIAddress eid = LispAFIConvertor.toAFI(key.getEID());
if (iterateMask && result.isEmpty() && MaskUtil.isMaskable(eid)) {
result = findMaskLocators(dao, key);
return result;
}
- private static List<MappingServiceRLOCGroup> aggregateLocators(Map<String, ?> locators) {
- List<MappingServiceRLOCGroup> result = new ArrayList<MappingServiceRLOCGroup>();
+ private static List<RLOCGroup> aggregateLocators(Map<String, ?> locators) {
+ List<RLOCGroup> result = new ArrayList<RLOCGroup>();
if (locators != null) {
for (Object value : locators.values()) {
- if (value != null && value instanceof MappingServiceRLOCGroup) {
- result.add((MappingServiceRLOCGroup) value);
+ if (value != null && value instanceof RLOCGroup) {
+ result.add((RLOCGroup) value);
}
}
}
return result;
}
- public static Object getLocatorsSpecific(IMappingServiceKey key, ILispDAO dao, String subkey, boolean iterateMask) {
+ public static Object getLocatorsSpecific(IMappingKey key, ILispDAO dao, String subkey, boolean iterateMask) {
Object locators = dao.getSpecific(key, subkey);
LispAFIAddress eid = LispAFIConvertor.toAFI(key.getEID());
if (iterateMask && locators == null && MaskUtil.isMaskable(eid)) {
return locators;
}
- private static Object findMaskLocatorsSpecific(IMappingServiceKey key, ILispDAO dao, String subkey) {
+ private static Object findMaskLocatorsSpecific(IMappingKey key, ILispDAO dao, String subkey) {
int mask = key.getMask();
while (mask > 0) {
LispAFIAddress eid = LispAFIConvertor.toAFI(key.getEID());
- key = MappingServiceKeyUtil.generateMappingServiceKey(
- LispAFIConvertor.toContainer(MaskUtil.normalize(eid, mask)), mask);
+ key = MappingKeyUtil.generateMappingKey(LispAFIConvertor.toContainer(MaskUtil.normalize(eid, mask)), mask);
mask--;
Object locators = dao.getSpecific(key, subkey);
if (locators != null) {
return null;
}
- private static List<MappingServiceRLOCGroup> findMaskLocators(ILispDAO dao, IMappingServiceKey key) {
+ private static List<RLOCGroup> findMaskLocators(ILispDAO dao, IMappingKey key) {
int mask = key.getMask();
while (mask > 0) {
LispAFIAddress eid = LispAFIConvertor.toAFI(key.getEID());
- key = MappingServiceKeyUtil.generateMappingServiceKey(
- LispAFIConvertor.toContainer(MaskUtil.normalize(eid, mask)), mask);
+ key = MappingKeyUtil.generateMappingKey(LispAFIConvertor.toContainer(MaskUtil.normalize(eid, mask)), mask);
mask--;
Map<String, ?> locators = dao.get(key);
if (locators != null) {
- List<MappingServiceRLOCGroup> result = aggregateLocators(locators);
+ List<RLOCGroup> result = aggregateLocators(locators);
if (result != null && !result.isEmpty()) {
return result;
}
return null;
}
- public static Entry<IMappingServiceKey, List<MappingServiceRLOCGroup>> getMapping(LispAFIAddress srcEid, EidRecord eid,
+ public static Entry<IMappingKey, List<RLOCGroup>> getMapping(LispAFIAddress srcEid, EidRecord eidRecord,
ILispDAO dao) {
// a map-request for an actual SrcDst LCAF, ignore src eid
- if (eid.getLispAddressContainer().getAddress() instanceof LcafSourceDest) {
- LcafSourceDestAddr eidAddr = ((LcafSourceDest) eid.getLispAddressContainer().getAddress()).getLcafSourceDestAddr();
- LispAFIAddress srcAddr = LispAFIConvertor.toAFIfromPrimitive(eidAddr.getSrcAddress().getPrimitiveAddress());
- LispAFIAddress dstAddr = LispAFIConvertor.toAFIfromPrimitive(eidAddr.getDstAddress().getPrimitiveAddress());
- return getMapping(srcAddr, dstAddr, eidAddr.getSrcMaskLength(), eidAddr.getDstMaskLength(), dao);
+ if (eidRecord.getLispAddressContainer().getAddress() instanceof LcafSourceDest) {
+ LcafSourceDestAddr eid = ((LcafSourceDest) eidRecord.getLispAddressContainer().getAddress())
+ .getLcafSourceDestAddr();
+ LispAFIAddress srcAddr = LispAFIConvertor.toAFIfromPrimitive(eid.getSrcAddress().getPrimitiveAddress());
+ LispAFIAddress dstAddr = LispAFIConvertor.toAFIfromPrimitive(eid.getDstAddress().getPrimitiveAddress());
+ return getMapping(srcAddr, dstAddr, eid.getSrcMaskLength(), eid.getDstMaskLength(), dao);
}
// potential map-request for SrcDst LCAF from non SrcDst capable devices
- Entry<IMappingServiceKey, List<MappingServiceRLOCGroup>> mapping = getMapping(srcEid,
- LispAFIConvertor.toAFI(eid.getLispAddressContainer()), (short) MaskUtil.getMaxMask(srcEid), eid.getMask(), dao);
+ Entry<IMappingKey, List<RLOCGroup>> mapping = getMapping(srcEid,
+ LispAFIConvertor.toAFI(eidRecord.getLispAddressContainer()), (short) MaskUtil.getMaxMask(srcEid),
+ eidRecord.getMask(), dao);
// if indeed SrcDst LCAF change the key to matched dst eid
if (mapping.getKey().getEID().getAddress() instanceof LcafSourceDest) {
- LcafSourceDestAddr srcDst = ((LcafSourceDest)mapping.getKey().getEID().getAddress()).getLcafSourceDestAddr();
- IMappingServiceKey newKey = MappingServiceKeyUtil.generateMappingServiceKey(LispAFIConvertor.
- toAFIfromPrimitive(srcDst.getDstAddress().getPrimitiveAddress()), srcDst.getDstMaskLength());
+ LcafSourceDestAddr srcDst = ((LcafSourceDest) mapping.getKey().getEID().getAddress())
+ .getLcafSourceDestAddr();
+ IMappingKey newKey = MappingKeyUtil.generateMappingKey(
+ LispAFIConvertor.toAFIfromPrimitive(srcDst.getDstAddress().getPrimitiveAddress()),
+ srcDst.getDstMaskLength());
return new AbstractMap.SimpleImmutableEntry<>(newKey, mapping.getValue());
}
return mapping;
}
- public static Entry<IMappingServiceKey, List<MappingServiceRLOCGroup>> getMapping(LispAFIAddress srcEid,
- LispAFIAddress dstEid, short srcMask, short dstMask, ILispDAO dao) {
- IMappingServiceKey key = MappingServiceKeyUtil.generateMappingServiceKey(dstEid, dstMask);
- Entry<IMappingServiceKey, Map<String, ?>> daoEntry = getDaoEntry(key, dao);
+ public static Entry<IMappingKey, List<RLOCGroup>> getMapping(LispAFIAddress srcEid, LispAFIAddress dstEid,
+ short srcMask, short dstMask, ILispDAO dao) {
+ IMappingKey key = MappingKeyUtil.generateMappingKey(dstEid, dstMask);
+ Entry<IMappingKey, Map<String, ?>> daoEntry = getDaoEntry(key, dao);
if (daoEntry != null) {
// try SrcDst eid lookup
- ILispDAO srcDstDao = (ILispDAO) daoEntry.getValue().get(AbstractLispComponent.LCAF_SRCDST_SUBKEY);
+ ILispDAO srcDstDao = (ILispDAO) daoEntry.getValue().get(DAOSubKeys.LCAF_SRCDST_SUBKEY.toString());
if (srcDstDao != null) {
- Entry<IMappingServiceKey, List<MappingServiceRLOCGroup>> mapping = getMappingForEid(srcEid, srcMask, srcDstDao);
+ Entry<IMappingKey, List<RLOCGroup>> mapping = getMappingForEid(srcEid, srcMask, srcDstDao);
// if lookup fails, return whatever is found for dst eid
if (mapping.getValue() != null) {
LispAFIAddress newDst = LispAFIConvertor.toAFI(daoEntry.getKey().getEID());
LispAFIAddress newSrc = LispAFIConvertor.toAFI(mapping.getKey().getEID());
LispAFIAddress newEid = new LcafSourceDestAddrBuilder()
- .setDstAddress(new DstAddressBuilder().setPrimitiveAddress(LispAFIConvertor.toPrimitive(newDst)).build())
- .setSrcAddress(new SrcAddressBuilder().setPrimitiveAddress(LispAFIConvertor.toPrimitive(newSrc)).build())
- .setDstMaskLength((short)daoEntry.getKey().getMask()).setSrcMaskLength((short)mapping.getKey().getMask())
- .setAfi((short)16387).setLcafType((short)12).build();
- IMappingServiceKey newKey = MappingServiceKeyUtil.generateMappingServiceKey(newEid, dstMask);
+ .setDstAddress(
+ new DstAddressBuilder().setPrimitiveAddress(LispAFIConvertor.toPrimitive(newDst))
+ .build())
+ .setSrcAddress(
+ new SrcAddressBuilder().setPrimitiveAddress(LispAFIConvertor.toPrimitive(newSrc))
+ .build()).setDstMaskLength((short) daoEntry.getKey().getMask())
+ .setSrcMaskLength((short) mapping.getKey().getMask()).setAfi((short) 16387)
+ .setLcafType((short) 12).build();
+ IMappingKey newKey = MappingKeyUtil.generateMappingKey(newEid, dstMask);
return new AbstractMap.SimpleImmutableEntry<>(newKey, mapping.getValue());
}
}
return new AbstractMap.SimpleImmutableEntry<>(key, null);
}
- public static Entry<IMappingServiceKey, List<MappingServiceRLOCGroup>> getMappingExact(LispAFIAddress srcEid,
- LispAFIAddress dstEid, short srcMask, short dstMask, ILispDAO dao) {
- IMappingServiceKey dstKey = MappingServiceKeyUtil.generateMappingServiceKey(dstEid, dstMask);
+ public static Entry<IMappingKey, List<RLOCGroup>> getMappingExact(LispAFIAddress srcEid, LispAFIAddress dstEid,
+ short srcMask, short dstMask, ILispDAO dao) {
+ IMappingKey dstKey = MappingKeyUtil.generateMappingKey(dstEid, dstMask);
Map<String, ?> daoEntry = dao.get(dstKey);
if (daoEntry != null) {
// try SrcDst eid lookup
- ILispDAO srcDstDao = (ILispDAO) daoEntry.get(AbstractLispComponent.LCAF_SRCDST_SUBKEY);
+ ILispDAO srcDstDao = (ILispDAO) daoEntry.get(DAOSubKeys.LCAF_SRCDST_SUBKEY.toString());
// if lookup fails, return whatever is found for dst eid
if (srcDstDao != null) {
- IMappingServiceKey srcKey = MappingServiceKeyUtil.generateMappingServiceKey(srcEid, srcMask);
+ IMappingKey srcKey = MappingKeyUtil.generateMappingKey(srcEid, srcMask);
Map<String, ?> mapping = srcDstDao.get(srcKey);
LispAFIAddress newEid = new LcafSourceDestAddrBuilder()
- .setDstAddress(new DstAddressBuilder().setPrimitiveAddress(LispAFIConvertor.toPrimitive(dstEid)).build())
- .setSrcAddress(new SrcAddressBuilder().setPrimitiveAddress(LispAFIConvertor.toPrimitive(srcEid)).build())
- .setDstMaskLength((short)dstMask).setSrcMaskLength((short)srcMask)
- .setAfi((short)16387).setLcafType((short)12).build();
- IMappingServiceKey newKey = MappingServiceKeyUtil.generateMappingServiceKey(newEid, dstMask);
+ .setDstAddress(
+ new DstAddressBuilder().setPrimitiveAddress(LispAFIConvertor.toPrimitive(dstEid))
+ .build())
+ .setSrcAddress(
+ new SrcAddressBuilder().setPrimitiveAddress(LispAFIConvertor.toPrimitive(srcEid))
+ .build()).setDstMaskLength((short) dstMask).setSrcMaskLength((short) srcMask)
+ .setAfi((short) 16387).setLcafType((short) 12).build();
+ IMappingKey newKey = MappingKeyUtil.generateMappingKey(newEid, dstMask);
return makeMappingEntry(newKey, mapping);
}
return new AbstractMap.SimpleImmutableEntry<>(dstKey, null);
}
- public static Entry<IMappingServiceKey, List<MappingServiceRLOCGroup>> getMappingForEidRecord(EidRecord eid, ILispDAO dao) {
+ public static Entry<IMappingKey, List<RLOCGroup>> getMappingForEidRecord(EidRecord eid, ILispDAO dao) {
return getMappingForEid(LispAFIConvertor.toAFI(eid.getLispAddressContainer()), eid.getMask(), dao);
}
- private static Entry<IMappingServiceKey, List<MappingServiceRLOCGroup>> makeMappingEntry(IMappingServiceKey key, Map<String, ?> locators) {
+ private static Entry<IMappingKey, List<RLOCGroup>> makeMappingEntry(IMappingKey key, Map<String, ?> locators) {
if (locators != null) {
- List<MappingServiceRLOCGroup> locatorsList = aggregateLocators(locators);
+ List<RLOCGroup> locatorsList = aggregateLocators(locators);
if (locatorsList != null && !locatorsList.isEmpty()) {
return new AbstractMap.SimpleImmutableEntry<>(key, locatorsList);
}
return new AbstractMap.SimpleImmutableEntry<>(key, null);
}
- public static Entry<IMappingServiceKey, List<MappingServiceRLOCGroup>> getMappingForEid(LispAFIAddress eid,
- int maskLen, ILispDAO dao) {
+ public static Entry<IMappingKey, List<RLOCGroup>> getMappingForEid(LispAFIAddress eid, int maskLen, ILispDAO dao) {
if (eid instanceof LcafSourceDestAddr) {
- LispAFIAddress srcAddr = LispAFIConvertor.toAFIfromPrimitive(((LcafSourceDestAddr) eid).getSrcAddress().getPrimitiveAddress());
- LispAFIAddress dstAddr = LispAFIConvertor.toAFIfromPrimitive(((LcafSourceDestAddr) eid).getDstAddress().getPrimitiveAddress());
+ LispAFIAddress srcAddr = LispAFIConvertor.toAFIfromPrimitive(((LcafSourceDestAddr) eid).getSrcAddress()
+ .getPrimitiveAddress());
+ LispAFIAddress dstAddr = LispAFIConvertor.toAFIfromPrimitive(((LcafSourceDestAddr) eid).getDstAddress()
+ .getPrimitiveAddress());
return getMapping(srcAddr, dstAddr, ((LcafSourceDestAddr) eid).getSrcMaskLength(),
((LcafSourceDestAddr) eid).getDstMaskLength(), dao);
}
- IMappingServiceKey key = MappingServiceKeyUtil.generateMappingServiceKey(eid, maskLen);
- Entry<IMappingServiceKey, Map<String, ?>> entry = getDaoEntry(key, dao);
+ IMappingKey key = MappingKeyUtil.generateMappingKey(eid, maskLen);
+ Entry<IMappingKey, Map<String, ?>> entry = getDaoEntry(key, dao);
if (entry == null) {
return makeMappingEntry(key, null);
} else {
}
}
- public static Entry<IMappingServiceKey, Map<String, ?>> getDaoEntry(IMappingServiceKey lookupKey, ILispDAO dao) {
+ public static Entry<IMappingKey, Map<String, ?>> getDaoEntry(IMappingKey lookupKey, ILispDAO dao) {
LispAFIAddress eidAddress = LispAFIConvertor.toAFI(lookupKey.getEID());
if (MaskUtil.isMaskable(eidAddress)) {
- IMappingServiceKey key;
+ IMappingKey key;
int mask = lookupKey.getMask();
while (mask > 0) {
- key = MappingServiceKeyUtil.generateMappingServiceKey(eidAddress, mask);
+ key = MappingKeyUtil.generateMappingKey(eidAddress, mask);
mask--;
Map<String, ?> entry = dao.get(key);
if (entry != null) {
- return new AbstractMap.SimpleImmutableEntry<IMappingServiceKey, Map<String, ?>>(key, entry);
+ return new AbstractMap.SimpleImmutableEntry<IMappingKey, Map<String, ?>>(key, entry);
}
}
return null;
} else {
Map<String, ?> entry = dao.get(lookupKey);
if (entry != null) {
- return new AbstractMap.SimpleImmutableEntry<IMappingServiceKey, Map<String, ?>>(lookupKey,
+ return new AbstractMap.SimpleImmutableEntry<IMappingKey, Map<String, ?>>(lookupKey,
dao.get(lookupKey));
} else {
return null;
}
}
}
+
+ public static void addSubscribers(LispAddressContainer eid, int mask, Set<SubscriberRLOC> subscribers,
+ ILispDAO dao) {
+ IMappingKey key = MappingKeyUtil.generateMappingKey(eid, mask);
+ dao.put(key, new MappingEntry<Set<SubscriberRLOC>>(DAOSubKeys.SUBSCRIBERS_SUBKEY.toString(), subscribers));
+ }
+
+ public static void addAuthenticationKey(LispAddressContainer address, int maskLen, String key, ILispDAO dao) {
+ IMappingKey mappingServiceKey = MappingKeyUtil.generateMappingKey(address, maskLen);
+ if (address.getAddress() instanceof LcafSourceDest) {
+ IMappingKey srcKey = MappingKeyUtil.generateMappingKey(getSrcForLcafSrcDst(address),
+ getSrcMaskForLcafSrcDst(address));
+ ILispDAO srcDstDao = getOrInstantiateSrcDstInnerDao(address, maskLen, dao);
+ srcDstDao.put(srcKey, new MappingEntry<String>(DAOSubKeys.PASSWORD_SUBKEY.toString(), key));
+ } else {
+ dao.put(mappingServiceKey, new MappingEntry<String>(DAOSubKeys.PASSWORD_SUBKEY.toString(), key));
+ }
+ }
+
+ public static String getPasswordForMaskable(LispAddressContainer prefix, int maskLength, ILispDAO db,
+ boolean shouldIterate) {
+ while (maskLength >= 0) {
+ IMappingKey key = MappingKeyUtil.generateMappingKey(prefix, maskLength);
+ Object password = db.getSpecific(key, DAOSubKeys.PASSWORD_SUBKEY.toString());
+ if (password != null && password instanceof String) {
+ return (String) password;
+ } else if (shouldIterate) {
+ maskLength -= 1;
+ } else {
+ LOG.warn("Failed to find password!");
+ return null;
+ }
+ }
+ return null;
+ }
+
+ public static String getPassword(LispAddressContainer prefix, int maskLength, ILispDAO dao, boolean iterate) {
+ if (MaskUtil.isMaskable(LispAFIConvertor.toAFI(prefix))) {
+ return getPasswordForMaskable(prefix, maskLength, dao, iterate);
+ } else if (prefix.getAddress() instanceof LcafSourceDest) {
+ ILispDAO srcDstDao = getSrcDstInnerDao(prefix, maskLength, dao);
+ if (srcDstDao != null) {
+ return getPasswordForMaskable(LispAFIConvertor.toContainer(getSrcForLcafSrcDst(prefix)),
+ getSrcMaskForLcafSrcDst(prefix), srcDstDao, iterate);
+ }
+ return null;
+ } else {
+ IMappingKey key = MappingKeyUtil.generateMappingKey(prefix, maskLength);
+ Object password = dao.getSpecific(key, DAOSubKeys.PASSWORD_SUBKEY.toString());
+ if (password != null && password instanceof String) {
+ return (String) password;
+ } else {
+ LOG.warn("Failed to find password!");
+ return null;
+ }
+ }
+ }
+
+ @SuppressWarnings("unchecked")
+ public static Set<SubscriberRLOC> getSubscribers(LispAddressContainer prefix, int maskLength, ILispDAO dao) {
+ Object subscribers;
+ if (prefix.getAddress() instanceof LcafSourceDest) {
+ IMappingKey srcKey = MappingKeyUtil.generateMappingKey(getSrcForLcafSrcDst(prefix),
+ getSrcMaskForLcafSrcDst(prefix));
+ ILispDAO srcDstDao = getSrcDstInnerDao(prefix, maskLength, dao);
+ subscribers = srcDstDao.getSpecific(srcKey, DAOSubKeys.SUBSCRIBERS_SUBKEY.toString());
+ } else {
+ IMappingKey key = MappingKeyUtil.generateMappingKey(prefix, maskLength);
+ subscribers = dao.getSpecific(key, DAOSubKeys.SUBSCRIBERS_SUBKEY.toString());
+ }
+
+ if (subscribers != null && subscribers instanceof Set<?>) {
+ return (Set<SubscriberRLOC>) subscribers;
+ }
+ return null;
+ }
+
+ // 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.
+ public static ILispDAO getOrInstantiateSrcDstInnerDao(LispAddressContainer address, int maskLen, ILispDAO dao) {
+ IMappingKey dstKey = MappingKeyUtil.generateMappingKey(getDstForLcafSrcDst(address),
+ getDstMaskForLcafSrcDst(address));
+ ILispDAO srcDstDao = (ILispDAO) dao.getSpecific(dstKey, DAOSubKeys.LCAF_SRCDST_SUBKEY.toString());
+ if (srcDstDao == null) {
+ srcDstDao = new HashMapDb();
+ dao.put(dstKey, new MappingEntry<>(DAOSubKeys.LCAF_SRCDST_SUBKEY.toString(), srcDstDao));
+ }
+ return srcDstDao;
+ }
+
+ // 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 null if it doesn't exist.
+ public static ILispDAO getSrcDstInnerDao(LispAddressContainer address, int maskLen, ILispDAO dao) {
+ IMappingKey dstKey = MappingKeyUtil.generateMappingKey(getDstForLcafSrcDst(address),
+ getDstMaskForLcafSrcDst(address));
+ return (ILispDAO) dao.getSpecific(dstKey, DAOSubKeys.LCAF_SRCDST_SUBKEY.toString());
+ }
+
+ public static boolean saveRlocs(EidToLocatorRecord eidRecord, boolean checkForChanges, ILispDAO dao,
+ boolean shouldIterate, boolean shouldOverwrite) {
+ Map<String, RLOCGroup> rlocGroups = new HashMap<String, RLOCGroup>();
+ if (eidRecord.getLocatorRecord() != null) {
+ for (LocatorRecord locatorRecord : eidRecord.getLocatorRecord()) {
+ String subkey = getAddressKey(locatorRecord.getLispAddressContainer().getAddress(), shouldOverwrite);
+ if (!rlocGroups.containsKey(subkey)) {
+ rlocGroups
+ .put(subkey,
+ new RLOCGroup(eidRecord.getRecordTtl(), eidRecord.getAction(), eidRecord
+ .isAuthoritative()));
+ }
+ rlocGroups.get(subkey).addRecord(locatorRecord);
+ }
+ } else {
+ rlocGroups.put(DAOSubKeys.ADDRESS_SUBKEY.toString(),
+ new RLOCGroup(eidRecord.getRecordTtl(), eidRecord.getAction(), eidRecord.isAuthoritative()));
+ }
+ List<MappingEntry<RLOCGroup>> entries = new ArrayList<>();
+ for (String subkey : rlocGroups.keySet()) {
+ entries.add(new MappingEntry<>(subkey, rlocGroups.get(subkey)));
+ }
+
+ if (eidRecord.getLispAddressContainer().getAddress() instanceof LcafSourceDest) {
+ Entry<IMappingKey, List<RLOCGroup>> oldMapping = null, newMapping = null;
+ LispAFIAddress srcAddr = getSrcForLcafSrcDst(eidRecord.getLispAddressContainer());
+ LispAFIAddress dstAddr = getDstForLcafSrcDst(eidRecord.getLispAddressContainer());
+ short srcMask = getSrcMaskForLcafSrcDst(eidRecord.getLispAddressContainer());
+ short dstMask = getDstMaskForLcafSrcDst(eidRecord.getLispAddressContainer());
+
+ if (checkForChanges) {
+ oldMapping = DAOMappingUtil.getMappingExact(srcAddr, dstAddr, srcMask, dstMask, dao);
+ }
+ IMappingKey dstKey = MappingKeyUtil.generateMappingKey(dstAddr, dstMask);
+ ILispDAO srcDstDao = (ILispDAO) dao.getSpecific(dstKey, DAOSubKeys.LCAF_SRCDST_SUBKEY.toString());
+ if (srcDstDao == null) {
+ srcDstDao = new HashMapDb();
+ dao.put(dstKey, new MappingEntry<>(DAOSubKeys.LCAF_SRCDST_SUBKEY.toString(), srcDstDao));
+ }
+ IMappingKey srcKey = MappingKeyUtil.generateMappingKey(srcAddr, srcMask);
+ srcDstDao.put(srcKey, entries.toArray(new MappingEntry[entries.size()]));
+ if (checkForChanges) {
+ newMapping = DAOMappingUtil.getMappingExact(srcAddr, dstAddr, srcMask, dstMask, dao);
+ return (newMapping.getValue() == null) ? oldMapping.getValue() != null : !newMapping.getValue()
+ .equals(oldMapping.getValue());
+ }
+ } else {
+ List<RLOCGroup> oldLocators = null, newLocators = null;
+ if (checkForChanges) {
+ oldLocators = DAOMappingUtil.getLocatorsByEidToLocatorRecord(eidRecord, dao, shouldIterate);
+ }
+ IMappingKey key = MappingKeyUtil.generateMappingKey(eidRecord.getLispAddressContainer(),
+ eidRecord.getMaskLength());
+ dao.put(key, entries.toArray(new MappingEntry[entries.size()]));
+ if (checkForChanges) {
+ newLocators = DAOMappingUtil.getLocatorsByEidToLocatorRecord(eidRecord, dao, shouldIterate);
+ return (newLocators == null) ? oldLocators != null : !newLocators.equals(oldLocators);
+ }
+ }
+ return false;
+ }
+
+ public static String getAddressKey(Address address, boolean shouldOverwrite) {
+ if (address instanceof LcafKeyValue) {
+ LcafKeyValue keyVal = (LcafKeyValue) address;
+ if (keyVal.getLcafKeyValueAddressAddr().getKey().getPrimitiveAddress() instanceof DistinguishedName) {
+ return ((DistinguishedName) keyVal.getLcafKeyValueAddressAddr().getKey().getPrimitiveAddress())
+ .getDistinguishedNameAddress().getDistinguishedName();
+ }
+ }
+ if (shouldOverwrite) {
+ return DAOSubKeys.ADDRESS_SUBKEY.toString();
+ } else {
+ return String.valueOf(address.hashCode());
+ }
+ }
+
+ public static void removeAuthenticationKey(LispAddressContainer address, int maskLen, ILispDAO dao) {
+ if (address.getAddress() instanceof LcafSourceDest) {
+ ILispDAO srcDstDao = getSrcDstInnerDao(address, maskLen, dao);
+ if (srcDstDao != null) {
+ IMappingKey srcKey = MappingKeyUtil.generateMappingKey(getSrcForLcafSrcDst(address),
+ getSrcMaskForLcafSrcDst(address));
+ srcDstDao.removeSpecific(srcKey, DAOSubKeys.PASSWORD_SUBKEY.toString());
+ }
+ } else {
+ IMappingKey key = MappingKeyUtil.generateMappingKey(address, maskLen);
+ dao.removeSpecific(key, DAOSubKeys.PASSWORD_SUBKEY.toString());
+ }
+ }
+
+ private static void removeMappingRlocs(Entry<IMappingKey, List<RLOCGroup>> mapping, ILispDAO db,
+ boolean shouldOverwrite) {
+ if (mapping == null || mapping.getValue() == null) {
+ return;
+ }
+ for (RLOCGroup group : mapping.getValue()) {
+ for (LocatorRecord record : group.getRecords()) {
+ db.removeSpecific(mapping.getKey(),
+ DAOMappingUtil.getAddressKey(record.getLispAddressContainer().getAddress(), shouldOverwrite));
+ }
+ }
+ }
+
+ public static void removeMapping(LispAddressContainer address, int maskLen, ILispDAO dao, boolean oerwrite) {
+ Entry<IMappingKey, List<RLOCGroup>> mapping;
+ ILispDAO db;
+ if (address.getAddress() instanceof LcafSourceDest) {
+ db = getSrcDstInnerDao(address, maskLen, dao);
+ LispAFIAddress srcAddr = getSrcForLcafSrcDst(address);
+ short srcMask = getSrcMaskForLcafSrcDst(address);
+ mapping = DAOMappingUtil.getMappingForEid(srcAddr, srcMask, db);
+ } else {
+ db = dao;
+ mapping = DAOMappingUtil.getMappingForEid(LispAFIConvertor.toAFI(address), maskLen, db);
+ }
+ removeMappingRlocs(mapping, db, oerwrite);
+ }
+
+ public static void removeSubscribers(LispAddressContainer address, int maskLen, ILispDAO dao,
+ boolean shouldOverwrite) {
+ Entry<IMappingKey, List<RLOCGroup>> mapping;
+ ILispDAO db;
+ if (address.getAddress() instanceof LcafSourceDest) {
+ db = getSrcDstInnerDao(address, maskLen, dao);
+ LispAFIAddress srcAddr = getSrcForLcafSrcDst(address);
+ short srcMask = getSrcMaskForLcafSrcDst(address);
+ mapping = DAOMappingUtil.getMappingForEid(srcAddr, srcMask, db);
+ } else {
+ db = dao;
+ mapping = DAOMappingUtil.getMappingForEid(LispAFIConvertor.toAFI(address), maskLen, db);
+ }
+ db.removeSpecific(mapping.getKey(), DAOSubKeys.SUBSCRIBERS_SUBKEY.toString());
+ }
+
+ public static void removeEntry(LispAddressContainer address, int maskLen, ILispDAO dao, boolean shouldOverwrite) {
+ Entry<IMappingKey, List<RLOCGroup>> mapping;
+ ILispDAO db;
+ if (address.getAddress() instanceof LcafSourceDest) {
+ db = getSrcDstInnerDao(address, maskLen, dao);
+ LispAFIAddress srcAddr = getSrcForLcafSrcDst(address);
+ short srcMask = getSrcMaskForLcafSrcDst(address);
+ mapping = DAOMappingUtil.getMappingForEid(srcAddr, srcMask, db);
+ } else {
+ db = dao;
+ mapping = DAOMappingUtil.getMappingForEid(LispAFIConvertor.toAFI(address), maskLen, db);
+ }
+
+ db.remove(mapping.getKey());
+ }
+
+ public static LispAFIAddress getSrcForLcafSrcDst(LispAddressContainer container) {
+ return LispAFIConvertor.toAFIfromPrimitive(((LcafSourceDest) container.getAddress()).getLcafSourceDestAddr()
+ .getSrcAddress().getPrimitiveAddress());
+ }
+
+ public static LispAFIAddress getDstForLcafSrcDst(LispAddressContainer container) {
+ return LispAFIConvertor.toAFIfromPrimitive(((LcafSourceDest) container.getAddress()).getLcafSourceDestAddr()
+ .getDstAddress().getPrimitiveAddress());
+ }
+
+ public static short getSrcMaskForLcafSrcDst(LispAddressContainer container) {
+ return ((LcafSourceDest) container.getAddress()).getLcafSourceDestAddr().getSrcMaskLength();
+ }
+
+ public static short getDstMaskForLcafSrcDst(LispAddressContainer container) {
+ return ((LcafSourceDest) container.getAddress()).getLcafSourceDestAddr().getDstMaskLength();
+ }
+
}
--- /dev/null
+/*
+ * 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.lispflowmapping.implementation.util;
+
+/**
+ * Defines DAO Subkeys
+ *
+ * @author Florin Coras
+ *
+ */
+public enum DAOSubKeys {
+ PASSWORD_SUBKEY("password"),
+ ADDRESS_SUBKEY("address"),
+ SUBSCRIBERS_SUBKEY("subscribers"),
+ LCAF_SRCDST_SUBKEY("lcaf_srcdst"),
+ UNKOWN("-1");
+
+ private String key;
+
+ private DAOSubKeys(String key) {
+ this.key = key;
+ }
+
+ public String getKey() {
+ return key;
+ }
+
+ @Override
+ public String toString() {
+ return key;
+ }
+
+}
*/
package org.opendaylight.lispflowmapping.implementation.util;
+import org.opendaylight.lispflowmapping.lisp.util.LispAddressStringifier;
import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.mapping.database.rev150314.EidUri;
import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.mapping.database.rev150314.IidUri;
import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.mapping.database.rev150314.MappingDatabase;
*/
package org.opendaylight.lispflowmapping.implementation.util;
-import java.net.Inet4Address;
import java.net.InetAddress;
import java.net.UnknownHostException;
import java.util.ArrayList;
import java.util.List;
-import org.opendaylight.lispflowmapping.implementation.serializer.LispMessage;
+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.control.plane.rev150314.AddMapping;
import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.control.plane.rev150314.EidToLocatorRecord;
import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.control.plane.rev150314.LcafApplicationDataAddress;
import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.control.plane.rev150314.lispaddress.lispaddresscontainer.address.distinguishedname.DistinguishedName;
import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.control.plane.rev150314.lispaddress.lispaddresscontainer.address.lcafkeyvalue.LcafKeyValueAddressAddr;
import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.control.plane.rev150314.lispsimpleaddress.PrimitiveAddress;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.control.plane.rev150314.mapnotifynotification.MapNotify;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.control.plane.rev150314.mapnotifynotification.MapNotifyBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.control.plane.rev150314.mapregisternotification.MapRegister;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.control.plane.rev150314.mapregisternotification.MapRegisterBuilder;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.control.plane.rev150314.mapreplynotification.MapReply;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.control.plane.rev150314.mapreplynotification.MapReplyBuilder;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.control.plane.rev150314.maprequestnotification.MapRequest;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.control.plane.rev150314.maprequestnotification.MapRequestBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.control.plane.rev150314.transportaddress.TransportAddress;
import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.control.plane.rev150314.transportaddress.TransportAddressBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.mapping.database.rev150314.EidUri;
import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.mapping.database.rev150314.SiteId;
import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.mapping.database.rev150314.db.instance.Mapping;
import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.mapping.database.rev150314.db.instance.MappingBuilder;
-import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev100924.IpAddress;
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.Ipv4Address;
-import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev100924.Ipv6Address;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev100924.PortNumber;
public class LispNotificationHelper {
-
- public static MapRegister convertMapRegister(org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.control.plane.rev150314.MapRegister mapRegister) {
- return new MapRegisterBuilder().setAuthenticationData(mapRegister.getAuthenticationData())
- .setEidToLocatorRecord(mapRegister.getEidToLocatorRecord()).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.control.plane.rev150314.MapNotify mapNotify) {
- return new MapNotifyBuilder().setAuthenticationData(mapNotify.getAuthenticationData())
- .setEidToLocatorRecord(mapNotify.getEidToLocatorRecord()).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.control.plane.rev150314.MapRequest mapRequest) {
- return new MapRequestBuilder().setAuthoritative(mapRequest.isAuthoritative()).setEidRecord(mapRequest.getEidRecord())
- .setItrRloc(mapRequest.getItrRloc()).setMapDataPresent(mapRequest.isMapDataPresent()).setMapReply(mapRequest.getMapReply())
- .setNonce(mapRequest.getNonce()).setPitr(mapRequest.isPitr()).setProbe(mapRequest.isProbe()).setSmr(mapRequest.isSmr())
- .setSmrInvoked(mapRequest.isSmrInvoked()).setSourceEid(mapRequest.getSourceEid()).build();
- }
-
- public static MapReply convertMapReply(org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.control.plane.rev150314.MapReply mapReply) {
- return new MapReplyBuilder().setEchoNonceEnabled(mapReply.isEchoNonceEnabled()).setEidToLocatorRecord(mapReply.getEidToLocatorRecord())
- .setNonce(mapReply.getNonce()).setProbe(mapReply.isProbe()).setSecurityEnabled(mapReply.isSecurityEnabled()).build();
- }
-
- public static IpAddress getIpAddressFromInetAddress(InetAddress inetAddress) {
- if (inetAddress == null) {
- inetAddress = InetAddress.getLoopbackAddress();
- }
- if (inetAddress instanceof Inet4Address) {
- return new IpAddress(new Ipv4Address(inetAddress.getHostAddress()));
- } else {
- return new IpAddress(new Ipv6Address(inetAddress.getHostAddress()));
- }
- }
-
- public static InetAddress getInetAddressFromIpAddress(IpAddress ipAddress) {
- InetAddress address = null;
- if (ipAddress != null) {
- if (ipAddress.getIpv4Address() != null) {
- address = getAddressByName(ipAddress.getIpv4Address().getValue());
- } else if (ipAddress.getIpv6Address() != null) {
- address = getAddressByName(ipAddress.getIpv6Address().getValue());
- }
- }
- if (address == null) {
- address = InetAddress.getLoopbackAddress();
- }
- return address;
- }
-
public static TransportAddress getTransportAddressFromContainer(LispAddressContainer container) {
TransportAddressBuilder tab = new TransportAddressBuilder();
LispAFIAddress address = LispAFIConvertor.toAFI(container);
import java.nio.ByteBuffer;
import org.apache.commons.lang3.exception.ExceptionUtils;
+import org.opendaylight.lispflowmapping.lisp.util.LispAFIConvertor;
import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.control.plane.rev150314.LispAFIAddress;
import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.control.plane.rev150314.lcafsegmentaddress.AddressBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.control.plane.rev150314.lcafsegmentaddress.Address;
*/
package org.opendaylight.lispflowmapping.implementation.util;
+import org.opendaylight.lispflowmapping.lisp.util.LispAddressStringifier;
import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.mapping.database.rev150314.AddKeyInput;
import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.mapping.database.rev150314.AddMappingInput;
import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.mapping.database.rev150314.EidUri;
import junitx.framework.ArrayAssert;
import org.junit.Test;
-import org.opendaylight.lispflowmapping.implementation.serializer.MapRegisterSerializer;
-import org.opendaylight.lispflowmapping.implementation.util.LispAFIConvertor;
+import org.opendaylight.lispflowmapping.lisp.util.LispAFIConvertor;
+import org.opendaylight.lispflowmapping.lisp.serializer.MapRegisterSerializer;
import org.opendaylight.lispflowmapping.tools.junit.BaseTestCase;
import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.control.plane.rev150314.MapRegister;
import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.control.plane.rev150314.eidtolocatorrecords.EidToLocatorRecord;
import org.junit.Before;
import org.junit.Test;
import org.opendaylight.lispflowmapping.implementation.LispMappingService;
-import org.opendaylight.lispflowmapping.implementation.dao.MappingServiceKeyUtil;
-import org.opendaylight.lispflowmapping.implementation.util.LispAFIConvertor;
+import org.opendaylight.lispflowmapping.implementation.dao.MappingKeyUtil;
+import org.opendaylight.lispflowmapping.implementation.util.DAOSubKeys;
import org.opendaylight.lispflowmapping.interfaces.dao.ILispDAO;
-import org.opendaylight.lispflowmapping.interfaces.dao.IMappingServiceKey;
-import org.opendaylight.lispflowmapping.interfaces.dao.MappingServiceRLOCGroup;
+import org.opendaylight.lispflowmapping.interfaces.dao.IMappingKey;
+import org.opendaylight.lispflowmapping.interfaces.dao.RLOCGroup;
+import org.opendaylight.lispflowmapping.lisp.util.LispAFIConvertor;
import org.opendaylight.lispflowmapping.tools.junit.BaseTestCase;
import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.control.plane.rev150314.EidToLocatorRecord.Action;
import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.control.plane.rev150314.LispAFIAddress;
private LispAFIAddress v4Address;
private LispAFIAddress v6Address;
- private HashMap<IMappingServiceKey, Map<String, MappingServiceRLOCGroup>> daoResults;
+ private HashMap<IMappingKey, Map<String, RLOCGroup>> daoResults;
@Override
@Before
mapRequest = new MapRequestBuilder();
v4Address = LispAFIConvertor.asIPAfiAddress("1.2.3.4");
v6Address = LispAFIConvertor.asIPv6AfiAddress("0:0:0:0:0:0:0:1");
- daoResults = new HashMap<IMappingServiceKey, Map<String, MappingServiceRLOCGroup>>();
+ daoResults = new HashMap<IMappingKey, Map<String, RLOCGroup>>();
}
@Test
public void handleMapRequest_VerifyNativelyForwardAutherized() {
MapRequest mr = getDefaultMapRequest();
- Map<String, List<MappingServiceRLOCGroup>> result = new HashMap<String, List<MappingServiceRLOCGroup>>();
- result.put(AbstractLispComponent.ADDRESS_SUBKEY, new ArrayList<MappingServiceRLOCGroup>());
+ Map<String, List<RLOCGroup>> result = new HashMap<String, List<RLOCGroup>>();
+ result.put(DAOSubKeys.ADDRESS_SUBKEY.toString(), new ArrayList<RLOCGroup>());
MapReply mapReply = getNativelyForwardMapReply(mr, result);
assertEquals(Action.NativelyForward, eidToLocators.getAction());
}
- private MapReply getNativelyForwardMapReply(MapRequest mr, Map<String, List<MappingServiceRLOCGroup>> result) {
- allowing(lispDAO).get(wany(IMappingServiceKey.class));
+ private MapReply getNativelyForwardMapReply(MapRequest mr, Map<String, List<RLOCGroup>> result) {
+ allowing(lispDAO).get(wany(IMappingKey.class));
ret(result);
- allowing(lispDAO).getSpecific(wany(IMappingServiceKey.class), with(AbstractLispComponent.PASSWORD_SUBKEY));
+ allowing(lispDAO).getSpecific(wany(IMappingKey.class), with(DAOSubKeys.PASSWORD_SUBKEY.toString()));
ret("pass");
MapReply mapReply = testedMapResolver.handleMapRequest(mr);
return mapReply;
Assert.assertTrue(locatorRecord.isRouted());
}
- private Map<String, MappingServiceRLOCGroup> prepareMapping(EidToLocatorRecord... records) {
+ private Map<String, RLOCGroup> prepareMapping(EidToLocatorRecord... records) {
if (records.length > 0) {
for (EidToLocatorRecord eidToLocatorRecord : records) {
- Map<String, MappingServiceRLOCGroup> result = new HashMap<String, MappingServiceRLOCGroup>();
- MappingServiceRLOCGroup rlocs = new MappingServiceRLOCGroup(eidToLocatorRecord.getRecordTtl(), eidToLocatorRecord.getAction(),
+ Map<String, RLOCGroup> result = new HashMap<String, RLOCGroup>();
+ RLOCGroup rlocs = new RLOCGroup(eidToLocatorRecord.getRecordTtl(), eidToLocatorRecord.getAction(),
eidToLocatorRecord.isAuthoritative());
for (LocatorRecord locator : eidToLocatorRecord.getLocatorRecord()) {
rlocs.addRecord(locator);
}
- result.put(AbstractLispComponent.ADDRESS_SUBKEY, rlocs);
+ result.put(DAOSubKeys.ADDRESS_SUBKEY.toString(), rlocs);
daoResults.put(
- MappingServiceKeyUtil.generateMappingServiceKey(eidToLocatorRecord.getLispAddressContainer(),
+ MappingKeyUtil.generateMappingKey(eidToLocatorRecord.getLispAddressContainer(),
(short) eidToLocatorRecord.getMaskLength()), result);
}
}
- ValueSaverAction<IMappingServiceKey> daoGetSaverAction = new ValueSaverAction<IMappingServiceKey>() {
+ ValueSaverAction<IMappingKey> daoGetSaverAction = new ValueSaverAction<IMappingKey>() {
@Override
- protected boolean validate(IMappingServiceKey value) {
+ protected boolean validate(IMappingKey value) {
return true;
}
allowing(lispDAO).get(with(daoGetSaverAction));
will(daoGetSaverAction);
- allowing(lispDAO).getSpecific(wany(IMappingServiceKey.class), with(AbstractLispComponent.PASSWORD_SUBKEY));
+ allowing(lispDAO).getSpecific(wany(IMappingKey.class), with(DAOSubKeys.PASSWORD_SUBKEY.toString()));
- return daoResults.get(MappingServiceKeyUtil.generateMappingServiceKey(LispAFIConvertor.toContainer(v4Address)));
+ return daoResults.get(MappingKeyUtil.generateMappingKey(LispAFIConvertor.toContainer(v4Address)));
}
private MapRequestBuilder getDefaultMapRequestBuilder() {
import org.junit.Before;
import org.junit.Test;
import org.opendaylight.lispflowmapping.implementation.LispMappingService;
-import org.opendaylight.lispflowmapping.implementation.dao.MappingServiceKeyUtil;
-import org.opendaylight.lispflowmapping.implementation.serializer.MapRegisterSerializer;
-import org.opendaylight.lispflowmapping.implementation.util.LispAFIConvertor;
+import org.opendaylight.lispflowmapping.implementation.dao.MappingKeyUtil;
+import org.opendaylight.lispflowmapping.implementation.util.DAOSubKeys;
import org.opendaylight.lispflowmapping.interfaces.dao.ILispDAO;
-import org.opendaylight.lispflowmapping.interfaces.dao.IMappingServiceKey;
+import org.opendaylight.lispflowmapping.interfaces.dao.IMappingKey;
import org.opendaylight.lispflowmapping.interfaces.dao.MappingEntry;
-import org.opendaylight.lispflowmapping.interfaces.dao.MappingServiceRLOCGroup;
+import org.opendaylight.lispflowmapping.interfaces.dao.RLOCGroup;
+import org.opendaylight.lispflowmapping.lisp.util.LispAFIConvertor;
+import org.opendaylight.lispflowmapping.lisp.serializer.MapRegisterSerializer;
import org.opendaylight.lispflowmapping.tools.junit.BaseTestCase;
import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.control.plane.rev150314.EidToLocatorRecord.Action;
import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.control.plane.rev150314.LispAFIAddress;
MappingEntry<?>[] entries = mappingEntriesSaver.lastValue;
assertEquals(1, entries.length);
- assertEquals(AbstractLispComponent.ADDRESS_SUBKEY, entries[0].getKey());
- assertEquals(1, ((MappingServiceRLOCGroup) entries[0].getValue()).getRecords().size());
- assertEquals(rloc, LispAFIConvertor.toAFI(((MappingServiceRLOCGroup) entries[0].getValue()).getRecords().get(0).getLispAddressContainer()));
+ assertEquals(DAOSubKeys.ADDRESS_SUBKEY.toString(), entries[0].getKey());
+ assertEquals(1, ((RLOCGroup) entries[0].getValue()).getRecords().size());
+ assertEquals(rloc, LispAFIConvertor.toAFI(((RLOCGroup) entries[0].getValue()).getRecords().get(0).getLispAddressContainer()));
}
@Test
MappingEntry<?>[] entries = mappingEntriesSaver.lastValue;
assertEquals(1, entries.length);
- assertEquals(AbstractLispComponent.ADDRESS_SUBKEY, entries[0].getKey());
- assertEquals(LispAFIConvertor.toContainer(rloc0), ((MappingServiceRLOCGroup) entries[0].getValue()).getRecords().get(0)
+ assertEquals(DAOSubKeys.ADDRESS_SUBKEY.toString(), entries[0].getKey());
+ assertEquals(LispAFIConvertor.toContainer(rloc0), ((RLOCGroup) entries[0].getValue()).getRecords().get(0)
.getLispAddressContainer());
- assertEquals(LispAFIConvertor.toContainer(rloc1), ((MappingServiceRLOCGroup) entries[0].getValue()).getRecords().get(1)
+ assertEquals(LispAFIConvertor.toContainer(rloc1), ((RLOCGroup) entries[0].getValue()).getRecords().get(1)
.getLispAddressContainer());
}
MappingEntry<?>[] entries = mappingEntriesSaver.lastValue;
assertEquals(2, entries.length);
- assertEquals(AbstractLispComponent.ADDRESS_SUBKEY, entries[0].getKey());
+ assertEquals(DAOSubKeys.ADDRESS_SUBKEY.toString(), entries[0].getKey());
assertEquals(subkey, entries[1].getKey());
- assertEquals(LispAFIConvertor.toContainer(rloc0), ((MappingServiceRLOCGroup) entries[0].getValue()).getRecords().get(0)
+ assertEquals(LispAFIConvertor.toContainer(rloc0), ((RLOCGroup) entries[0].getValue()).getRecords().get(0)
.getLispAddressContainer());
- assertEquals(LispAFIConvertor.toContainer(rloc1), ((MappingServiceRLOCGroup) entries[1].getValue()).getRecords().get(0)
+ assertEquals(LispAFIConvertor.toContainer(rloc1), ((RLOCGroup) entries[1].getValue()).getRecords().get(0)
.getLispAddressContainer());
}
MappingEntry<?>[] entries = mappingEntriesSaver.lastValue;
assertEquals(1, entries.length);
- assertEquals(AbstractLispComponent.ADDRESS_SUBKEY, entries[0].getKey());
- assertEquals(LispAFIConvertor.toContainer(rloc), ((MappingServiceRLOCGroup) entries[0].getValue()).getRecords().get(0)
+ assertEquals(DAOSubKeys.ADDRESS_SUBKEY.toString(), entries[0].getKey());
+ assertEquals(LispAFIConvertor.toContainer(rloc), ((RLOCGroup) entries[0].getValue()).getRecords().get(0)
.getLispAddressContainer());
}
assertEquals(1, entries.length);
assertEquals(String.valueOf(hc), entries[0].getKey());
- assertEquals(LispAFIConvertor.toContainer(rloc), ((MappingServiceRLOCGroup) entries[0].getValue()).getRecords().get(0)
+ assertEquals(LispAFIConvertor.toContainer(rloc), ((RLOCGroup) entries[0].getValue()).getRecords().get(0)
.getLispAddressContainer());
}
@Test
public void handleAddAuthenticationKey() throws Exception {
String password = "pass";
- IMappingServiceKey key = getDefualtKey();
+ IMappingKey key = getDefualtKey();
oneOf(lispDAO).put(weq(key),
- weq((MappingEntry<String>[]) (Arrays.asList(new MappingEntry<String>(AbstractLispComponent.PASSWORD_SUBKEY, password)).toArray())));
+ weq((MappingEntry<String>[]) (Arrays.asList(new MappingEntry<String>(DAOSubKeys.PASSWORD_SUBKEY.toString(), password)).toArray())));
testedMapServer.addAuthenticationKey(LispAFIConvertor.toContainer(eid), key.getMask(), password);
}
@Test
public void handleGetAuthenticationKey() throws Exception {
- IMappingServiceKey key = getDefualtKey();
- oneOf(lispDAO).getSpecific(weq(key), with(AbstractLispComponent.PASSWORD_SUBKEY));
+ IMappingKey key = getDefualtKey();
+ oneOf(lispDAO).getSpecific(weq(key), with(DAOSubKeys.PASSWORD_SUBKEY.toString()));
ret("password");
assertEquals("password", testedMapServer.getAuthenticationKey(LispAFIConvertor.toContainer(eid), key.getMask()));
}
@Test
public void handleGetAuthenticationKeyNoIteration() throws Exception {
testedMapServer.setShouldIterateMask(false);
- IMappingServiceKey key = getDefualtKey();
- IMappingServiceKey passKey = getKey(30);
- oneOf(lispDAO).getSpecific(weq(key), with(AbstractLispComponent.PASSWORD_SUBKEY));
- allowing(lispDAO).getSpecific(weq(passKey), with(AbstractLispComponent.PASSWORD_SUBKEY));
+ IMappingKey key = getDefualtKey();
+ IMappingKey passKey = getKey(30);
+ oneOf(lispDAO).getSpecific(weq(key), with(DAOSubKeys.PASSWORD_SUBKEY.toString()));
+ allowing(lispDAO).getSpecific(weq(passKey), with(DAOSubKeys.PASSWORD_SUBKEY.toString()));
ret("password");
assertEquals(null, testedMapServer.getAuthenticationKey(LispAFIConvertor.toContainer(eid), key.getMask()));
}
@Test
public void handleRemoveAuthenticationKey() throws Exception {
- IMappingServiceKey key = getDefualtKey();
- oneOf(lispDAO).removeSpecific(weq(key), with(AbstractLispComponent.PASSWORD_SUBKEY));
+ IMappingKey key = getDefualtKey();
+ oneOf(lispDAO).removeSpecific(weq(key), with(DAOSubKeys.PASSWORD_SUBKEY.toString()));
testedMapServer.removeAuthenticationKey(LispAFIConvertor.toContainer(eid), key.getMask());
}
}
private void addPutExpectations(LispAFIAddress address, int mask) {
- oneOf(lispDAO).put(weq(MappingServiceKeyUtil.generateMappingServiceKey(LispAFIConvertor.toContainer(address), mask)),
+ oneOf(lispDAO).put(weq(MappingKeyUtil.generateMappingKey(LispAFIConvertor.toContainer(address), mask)),
with(mappingEntriesSaver));
}
String result = null;
result = null;
allowing(lispDAO).getSpecific(
- with(MappingServiceKeyUtil.generateMappingServiceKey(LispAFIConvertor.toContainer(address), withoutPassword)), with("password"));
+ with(MappingKeyUtil.generateMappingKey(LispAFIConvertor.toContainer(address), withoutPassword)), with("password"));
ret(result);
}
if (withPassword > 0) {
String result = null;
result = password;
- allowing(lispDAO).getSpecific(with(MappingServiceKeyUtil.generateMappingServiceKey(LispAFIConvertor.toContainer(address), withPassword)),
+ allowing(lispDAO).getSpecific(with(MappingKeyUtil.generateMappingKey(LispAFIConvertor.toContainer(address), withPassword)),
with("password"));
ret(result);
}
for (int i = mask; i >= 0; i--) {
- allowing(lispDAO).getSpecific(with(MappingServiceKeyUtil.generateMappingServiceKey(LispAFIConvertor.toContainer(address), i)),
+ allowing(lispDAO).getSpecific(with(MappingKeyUtil.generateMappingKey(LispAFIConvertor.toContainer(address), i)),
with("password"));
ret(null);
}
}
- private IMappingServiceKey getDefualtKey() {
+ private IMappingKey getDefualtKey() {
return getKey(32);
}
- private IMappingServiceKey getKey(int mask) {
- IMappingServiceKey key = MappingServiceKeyUtil.generateMappingServiceKey(LispAFIConvertor.toContainer(eid), mask);
+ private IMappingKey getKey(int mask) {
+ IMappingKey key = MappingKeyUtil.generateMappingKey(LispAFIConvertor.toContainer(eid), mask);
return key;
}
import org.opendaylight.lispflowmapping.interfaces.dao.ILispDAO;
import org.opendaylight.lispflowmapping.interfaces.dao.IRowVisitor;
import org.opendaylight.lispflowmapping.interfaces.dao.MappingEntry;
-import org.opendaylight.lispflowmapping.interfaces.dao.MappingServiceRLOCGroup;
+import org.opendaylight.lispflowmapping.interfaces.dao.RLOCGroup;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
public void cleanOld() {
getAll(new IRowVisitor() {
public void visitRow(Object keyId, String valueKey, Object value) {
- if (value instanceof MappingServiceRLOCGroup) {
- MappingServiceRLOCGroup rloc = (MappingServiceRLOCGroup) value;
+ if (value instanceof RLOCGroup) {
+ RLOCGroup rloc = (RLOCGroup) value;
if (isExpired(rloc)) {
removeSpecific(keyId, valueKey);
}
}
}
- private boolean isExpired(MappingServiceRLOCGroup rloc) {
+ private boolean isExpired(RLOCGroup rloc) {
return System.currentTimeMillis() - rloc.getRegisterdDate().getTime() > TimeUnit.MILLISECONDS.convert(recordTimeOut, timeUnit);
}
});
import org.opendaylight.controller.mdsal.it.base.AbstractMdsalTestBase;
import org.opendaylight.controller.sal.binding.api.NotificationListener;
import org.opendaylight.lispflowmapping.implementation.LispMappingService;
-import org.opendaylight.lispflowmapping.implementation.serializer.LispMessage;
-import org.opendaylight.lispflowmapping.implementation.serializer.MapNotifySerializer;
-import org.opendaylight.lispflowmapping.implementation.serializer.MapRegisterSerializer;
-import org.opendaylight.lispflowmapping.implementation.serializer.MapReplySerializer;
-import org.opendaylight.lispflowmapping.implementation.serializer.MapRequestSerializer;
-import org.opendaylight.lispflowmapping.implementation.util.LispAFIConvertor;
import org.opendaylight.lispflowmapping.interfaces.lisp.IFlowMapping;
-import org.opendaylight.lispflowmapping.type.AddressFamilyNumberEnum;
-import org.opendaylight.lispflowmapping.type.LispCanonicalAddressFormatEnum;
+import org.opendaylight.lispflowmapping.lisp.type.AddressFamilyNumberEnum;
+import org.opendaylight.lispflowmapping.lisp.type.LispCanonicalAddressFormatEnum;
+import org.opendaylight.lispflowmapping.lisp.util.LispAFIConvertor;
+import org.opendaylight.lispflowmapping.lisp.type.LispMessage;
+import org.opendaylight.lispflowmapping.lisp.serializer.MapNotifySerializer;
+import org.opendaylight.lispflowmapping.lisp.serializer.MapRegisterSerializer;
+import org.opendaylight.lispflowmapping.lisp.serializer.MapReplySerializer;
+import org.opendaylight.lispflowmapping.lisp.serializer.MapRequestSerializer;
import org.opendaylight.lispflowmapping.type.sbplugin.IConfigLispSouthboundPlugin;
import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.control.plane.rev150314.EidToLocatorRecord.Action;
import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.control.plane.rev150314.LcafApplicationDataAddress;
<groupId>org.opendaylight.lispflowmapping</groupId>
<artifactId>mappingservice.api</artifactId>
</dependency>
- <dependency>
- <groupId>org.opendaylight.lispflowmapping</groupId>
- <artifactId>mappingservice.implementation</artifactId>
- </dependency>
<dependency>
<groupId>org.opendaylight.lispflowmapping</groupId>
<artifactId>mappingservice.yangmodel</artifactId>
import java.util.concurrent.Future;
import org.apache.commons.lang3.exception.ExceptionUtils;
-import org.opendaylight.lispflowmapping.implementation.util.LispAFIConvertor;
+import org.opendaylight.lispflowmapping.lisp.util.LispAFIConvertor;
import org.opendaylight.neutron.spi.INeutronPortAware;
import org.opendaylight.neutron.spi.NeutronPort;
import org.opendaylight.neutron.spi.Neutron_IPs;
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.implementation.util.LispAFIConvertor;
+import org.opendaylight.lispflowmapping.lisp.util.LispAFIConvertor;
import org.opendaylight.neutron.spi.INeutronSubnetAware;
import org.opendaylight.neutron.spi.NeutronSubnet;
import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.control.plane.rev150314.LispAFIAddress;
<version>1.3.0-SNAPSHOT</version>
</parent>
- <groupId>org.opendaylight.lispflowmapping</groupId>
<artifactId>mappingservice.southbound</artifactId>
- <version>1.3.0-SNAPSHOT</version>
<packaging>bundle</packaging>
<name>Mapping Service Southbound Plugin</name>
</dependency>
<dependency>
<groupId>${project.groupId}</groupId>
- <artifactId>mappingservice.implementation</artifactId>
+ <artifactId>mappingservice.yangmodel</artifactId>
<version>${project.version}</version>
</dependency>
</dependencies>
import java.nio.ByteBuffer;
import java.util.concurrent.Future;
-import org.opendaylight.lispflowmapping.implementation.serializer.MapNotifySerializer;
-import org.opendaylight.lispflowmapping.implementation.serializer.MapRegisterSerializer;
-import org.opendaylight.lispflowmapping.implementation.serializer.MapReplySerializer;
-import org.opendaylight.lispflowmapping.implementation.serializer.MapRequestSerializer;
+import org.opendaylight.lispflowmapping.lisp.serializer.MapNotifySerializer;
+import org.opendaylight.lispflowmapping.lisp.serializer.MapRegisterSerializer;
+import org.opendaylight.lispflowmapping.lisp.serializer.MapReplySerializer;
+import org.opendaylight.lispflowmapping.lisp.serializer.MapRequestSerializer;
import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.control.plane.rev150314.LfmControlPlaneService;
import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.control.plane.rev150314.SendMapNotifyInput;
import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.control.plane.rev150314.SendMapRegisterInput;
import org.opendaylight.controller.sal.binding.api.BindingAwareProvider;
import org.opendaylight.controller.sal.binding.api.NotificationProviderService;
import org.opendaylight.controller.sal.binding.api.RpcProviderRegistry;
-import org.opendaylight.lispflowmapping.implementation.serializer.LispMessage;
+import org.opendaylight.lispflowmapping.lisp.type.LispMessage;
import org.opendaylight.lispflowmapping.southbound.lisp.ILispSouthboundService;
import org.opendaylight.lispflowmapping.southbound.lisp.LispSouthboundService;
import org.opendaylight.lispflowmapping.southbound.lisp.LispXtrSouthboundService;
import java.nio.ByteBuffer;
import org.opendaylight.controller.sal.binding.api.NotificationProviderService;
-import org.opendaylight.lispflowmapping.implementation.serializer.LispMessage;
-import org.opendaylight.lispflowmapping.implementation.serializer.LispMessageEnum;
-import org.opendaylight.lispflowmapping.implementation.serializer.MapNotifySerializer;
-import org.opendaylight.lispflowmapping.implementation.serializer.MapRegisterSerializer;
-import org.opendaylight.lispflowmapping.implementation.serializer.MapReplySerializer;
-import org.opendaylight.lispflowmapping.implementation.serializer.MapRequestSerializer;
-import org.opendaylight.lispflowmapping.implementation.util.ByteUtil;
-import org.opendaylight.lispflowmapping.implementation.util.LispNotificationHelper;
-import org.opendaylight.lispflowmapping.implementation.util.MapRequestUtil;
+import org.opendaylight.lispflowmapping.southbound.util.LispNotificationHelper;
+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.MapRequestUtil;
+import org.opendaylight.lispflowmapping.lisp.serializer.MapNotifySerializer;
+import org.opendaylight.lispflowmapping.lisp.serializer.MapRegisterSerializer;
+import org.opendaylight.lispflowmapping.lisp.serializer.MapReplySerializer;
+import org.opendaylight.lispflowmapping.lisp.serializer.MapRequestSerializer;
import org.opendaylight.lispflowmapping.southbound.lisp.exception.LispMalformedPacketException;
import org.opendaylight.lispflowmapping.southbound.lisp.network.PacketHeader;
import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.control.plane.rev150314.AddMappingBuilder;
import java.nio.ByteBuffer;
import org.opendaylight.controller.sal.binding.api.NotificationProviderService;
-import org.opendaylight.lispflowmapping.implementation.serializer.LispMessage;
-import org.opendaylight.lispflowmapping.implementation.serializer.LispMessageEnum;
-import org.opendaylight.lispflowmapping.implementation.serializer.MapReplySerializer;
-import org.opendaylight.lispflowmapping.implementation.serializer.MapRequestSerializer;
-import org.opendaylight.lispflowmapping.implementation.util.ByteUtil;
-import org.opendaylight.lispflowmapping.implementation.util.LispNotificationHelper;
-import org.opendaylight.lispflowmapping.implementation.util.MapRequestUtil;
+import org.opendaylight.lispflowmapping.southbound.util.LispNotificationHelper;
+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.MapRequestUtil;
+import org.opendaylight.lispflowmapping.lisp.serializer.MapReplySerializer;
+import org.opendaylight.lispflowmapping.lisp.serializer.MapRequestSerializer;
import org.opendaylight.lispflowmapping.southbound.lisp.exception.LispMalformedPacketException;
import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.control.plane.rev150314.MapReply;
import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.control.plane.rev150314.MapRequest;
--- /dev/null
+/*
+ * Copyright (c) 2014 Contextream, Inc. and others. All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v1.0 which accompanies this distribution,
+ * and is available at http://www.eclipse.org/legal/epl-v10.html
+ */
+package org.opendaylight.lispflowmapping.southbound.util;
+
+import java.net.Inet4Address;
+import java.net.InetAddress;
+
+import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.control.plane.rev150314.mapnotifynotification.MapNotify;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.control.plane.rev150314.mapnotifynotification.MapNotifyBuilder;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.control.plane.rev150314.mapregisternotification.MapRegister;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.control.plane.rev150314.mapregisternotification.MapRegisterBuilder;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.control.plane.rev150314.mapreplynotification.MapReply;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.control.plane.rev150314.mapreplynotification.MapReplyBuilder;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.control.plane.rev150314.maprequestnotification.MapRequest;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.control.plane.rev150314.maprequestnotification.MapRequestBuilder;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev100924.IpAddress;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev100924.Ipv4Address;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev100924.Ipv6Address;
+
+public class LispNotificationHelper {
+ public static MapRegister convertMapRegister(
+ org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.control.plane.rev150314.MapRegister mapRegister) {
+ return new MapRegisterBuilder().setAuthenticationData(mapRegister.getAuthenticationData())
+ .setEidToLocatorRecord(mapRegister.getEidToLocatorRecord()).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.control.plane.rev150314.MapNotify mapNotify) {
+ return new MapNotifyBuilder().setAuthenticationData(mapNotify.getAuthenticationData())
+ .setEidToLocatorRecord(mapNotify.getEidToLocatorRecord()).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.control.plane.rev150314.MapRequest mapRequest) {
+ return new MapRequestBuilder().setAuthoritative(mapRequest.isAuthoritative())
+ .setEidRecord(mapRequest.getEidRecord()).setItrRloc(mapRequest.getItrRloc())
+ .setMapDataPresent(mapRequest.isMapDataPresent()).setMapReply(mapRequest.getMapReply())
+ .setNonce(mapRequest.getNonce()).setPitr(mapRequest.isPitr()).setProbe(mapRequest.isProbe())
+ .setSmr(mapRequest.isSmr()).setSmrInvoked(mapRequest.isSmrInvoked())
+ .setSourceEid(mapRequest.getSourceEid()).build();
+ }
+
+ public static MapReply convertMapReply(
+ org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.control.plane.rev150314.MapReply mapReply) {
+ return new MapReplyBuilder().setEchoNonceEnabled(mapReply.isEchoNonceEnabled())
+ .setEidToLocatorRecord(mapReply.getEidToLocatorRecord()).setNonce(mapReply.getNonce())
+ .setProbe(mapReply.isProbe()).setSecurityEnabled(mapReply.isSecurityEnabled()).build();
+ }
+
+ public static IpAddress getIpAddressFromInetAddress(InetAddress inetAddress) {
+ if (inetAddress == null) {
+ inetAddress = InetAddress.getLoopbackAddress();
+ }
+ if (inetAddress instanceof Inet4Address) {
+ return new IpAddress(new Ipv4Address(inetAddress.getHostAddress()));
+ } else {
+ return new IpAddress(new Ipv6Address(inetAddress.getHostAddress()));
+ }
+ }
+}
import org.junit.Ignore;
import org.junit.Test;
import org.opendaylight.controller.sal.binding.api.NotificationProviderService;
-import org.opendaylight.lispflowmapping.implementation.serializer.LispMessage;
-import org.opendaylight.lispflowmapping.implementation.serializer.LispMessageEnum;
-import org.opendaylight.lispflowmapping.implementation.serializer.MapNotifySerializer;
-import org.opendaylight.lispflowmapping.implementation.serializer.MapReplySerializer;
-import org.opendaylight.lispflowmapping.implementation.util.ByteUtil;
-import org.opendaylight.lispflowmapping.implementation.util.LispAFIConvertor;
-import org.opendaylight.lispflowmapping.implementation.util.MapNotifyBuilderHelper;
+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.MapNotifyBuilderHelper;
+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.lispflowmapping.type.AddressFamilyNumberEnum;
import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.control.plane.rev150314.AddMapping;
import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.control.plane.rev150314.EidToLocatorRecord.Action;
import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.control.plane.rev150314.LispAFIAddress;
<groupId>org.opendaylight.yangtools.model</groupId>
<artifactId>yang-ext</artifactId>
</dependency>
+ <dependency>
+ <groupId>org.apache.commons</groupId>
+ <artifactId>commons-lang3</artifactId>
+ </dependency>
+ <dependency>
+ <groupId>org.opendaylight.lispflowmapping</groupId>
+ <artifactId>common.unittest.tools</artifactId>
+ <version>${project.version}</version>
+ </dependency>
</dependencies>
</project>
* 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.lispflowmapping.implementation.serializer;
+package org.opendaylight.lispflowmapping.lisp.serializer;
import java.nio.ByteBuffer;
-import org.opendaylight.lispflowmapping.implementation.serializer.address.LispAddressSerializer;
-import org.opendaylight.lispflowmapping.implementation.util.ByteUtil;
-import org.opendaylight.lispflowmapping.implementation.util.LispAFIConvertor;
+import org.opendaylight.lispflowmapping.lisp.serializer.address.LispAddressSerializer;
+import org.opendaylight.lispflowmapping.lisp.util.ByteUtil;
+import org.opendaylight.lispflowmapping.lisp.util.LispAFIConvertor;
import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.control.plane.rev150314.LispAFIAddress;
import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.control.plane.rev150314.eidrecords.EidRecord;
import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.control.plane.rev150314.eidrecords.EidRecordBuilder;
* 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.lispflowmapping.implementation.serializer;
+package org.opendaylight.lispflowmapping.lisp.serializer;
import java.nio.ByteBuffer;
import java.util.ArrayList;
import org.apache.commons.lang3.BooleanUtils;
-import org.opendaylight.lispflowmapping.implementation.serializer.address.LispAddressSerializer;
-import org.opendaylight.lispflowmapping.implementation.util.ByteUtil;
-import org.opendaylight.lispflowmapping.implementation.util.LispAFIConvertor;
-import org.opendaylight.lispflowmapping.implementation.util.NumberUtil;
+import org.opendaylight.lispflowmapping.lisp.serializer.address.LispAddressSerializer;
+import org.opendaylight.lispflowmapping.lisp.util.ByteUtil;
+import org.opendaylight.lispflowmapping.lisp.util.LispAFIConvertor;
+import org.opendaylight.lispflowmapping.lisp.util.NumberUtil;
import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.control.plane.rev150314.EidToLocatorRecord;
import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.control.plane.rev150314.EidToLocatorRecord.Action;
import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.control.plane.rev150314.LispAFIAddress;
* 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.lispflowmapping.implementation.serializer;
+package org.opendaylight.lispflowmapping.lisp.serializer;
import java.nio.ByteBuffer;
import org.apache.commons.lang3.BooleanUtils;
-import org.opendaylight.lispflowmapping.implementation.serializer.address.LispAddressSerializer;
-import org.opendaylight.lispflowmapping.implementation.util.ByteUtil;
-import org.opendaylight.lispflowmapping.implementation.util.LispAFIConvertor;
-import org.opendaylight.lispflowmapping.implementation.util.LispAddressStringifier;
-import org.opendaylight.lispflowmapping.implementation.util.NumberUtil;
+import org.opendaylight.lispflowmapping.lisp.serializer.address.LispAddressSerializer;
+import org.opendaylight.lispflowmapping.lisp.util.ByteUtil;
+import org.opendaylight.lispflowmapping.lisp.util.LispAFIConvertor;
+import org.opendaylight.lispflowmapping.lisp.util.LispAddressStringifier;
+import org.opendaylight.lispflowmapping.lisp.util.NumberUtil;
import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.control.plane.rev150314.LispAFIAddress;
import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.control.plane.rev150314.lispaddress.LispAddressContainer;
import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.control.plane.rev150314.locatorrecords.LocatorRecord;
* 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.lispflowmapping.implementation.serializer;
+package org.opendaylight.lispflowmapping.lisp.serializer;
import java.nio.ByteBuffer;
import java.util.ArrayList;
-import org.opendaylight.lispflowmapping.implementation.lisp.exception.LispSerializationException;
-import org.opendaylight.lispflowmapping.implementation.util.ByteUtil;
-import org.opendaylight.lispflowmapping.implementation.util.NumberUtil;
+import org.opendaylight.lispflowmapping.lisp.serializer.exception.LispSerializationException;
+import org.opendaylight.lispflowmapping.lisp.type.LispMessageEnum;
+import org.opendaylight.lispflowmapping.lisp.util.ByteUtil;
+import org.opendaylight.lispflowmapping.lisp.util.NumberUtil;
import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.control.plane.rev150314.MapNotify;
import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.control.plane.rev150314.eidtolocatorrecords.EidToLocatorRecord;
import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.control.plane.rev150314.eidtolocatorrecords.EidToLocatorRecordBuilder;
size += mapNotify.getAuthenticationData().length;
}
if (mapNotify.isXtrSiteIdPresent() != null && mapNotify.isXtrSiteIdPresent()) {
- size += org.opendaylight.lispflowmapping.implementation.serializer.MapRegisterSerializer.Length.XTRID_SIZE +
- org.opendaylight.lispflowmapping.implementation.serializer.MapRegisterSerializer.Length.SITEID_SIZE;
+ size += org.opendaylight.lispflowmapping.lisp.serializer.MapRegisterSerializer.Length.XTRID_SIZE +
+ org.opendaylight.lispflowmapping.lisp.serializer.MapRegisterSerializer.Length.SITEID_SIZE;
}
for (EidToLocatorRecord eidToLocatorRecord : mapNotify.getEidToLocatorRecord()) {
size += EidToLocatorRecordSerializer.getInstance().getSerializationSize(eidToLocatorRecord);
}
if (xtrSiteIdPresent) {
- byte[] xtrId = new byte[org.opendaylight.lispflowmapping.implementation.serializer.MapRegisterSerializer.Length.XTRID_SIZE];
+ byte[] xtrId = new byte[org.opendaylight.lispflowmapping.lisp.serializer.MapRegisterSerializer.Length.XTRID_SIZE];
notifyBuffer.get(xtrId);
- byte[] siteId = new byte[org.opendaylight.lispflowmapping.implementation.serializer.MapRegisterSerializer.Length.SITEID_SIZE];
+ byte[] siteId = new byte[org.opendaylight.lispflowmapping.lisp.serializer.MapRegisterSerializer.Length.SITEID_SIZE];
notifyBuffer.get(siteId);
builder.setXtrId(xtrId);
builder.setSiteId(siteId);
* 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.lispflowmapping.implementation.serializer;
+package org.opendaylight.lispflowmapping.lisp.serializer;
import java.nio.ByteBuffer;
import java.util.ArrayList;
import org.apache.commons.lang3.BooleanUtils;
-import org.opendaylight.lispflowmapping.implementation.lisp.exception.LispSerializationException;
-import org.opendaylight.lispflowmapping.implementation.util.ByteUtil;
-import org.opendaylight.lispflowmapping.implementation.util.NumberUtil;
+import org.opendaylight.lispflowmapping.lisp.serializer.exception.LispSerializationException;
+import org.opendaylight.lispflowmapping.lisp.type.LispMessageEnum;
+import org.opendaylight.lispflowmapping.lisp.util.ByteUtil;
+import org.opendaylight.lispflowmapping.lisp.util.NumberUtil;
import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.control.plane.rev150314.MapRegister;
import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.control.plane.rev150314.eidtolocatorrecords.EidToLocatorRecord;
import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.control.plane.rev150314.eidtolocatorrecords.EidToLocatorRecordBuilder;
* 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.lispflowmapping.implementation.serializer;
+package org.opendaylight.lispflowmapping.lisp.serializer;
import java.nio.ByteBuffer;
import java.util.ArrayList;
import org.apache.commons.lang3.BooleanUtils;
-import org.opendaylight.lispflowmapping.implementation.util.ByteUtil;
-import org.opendaylight.lispflowmapping.implementation.util.NumberUtil;
+import org.opendaylight.lispflowmapping.lisp.type.LispMessageEnum;
+import org.opendaylight.lispflowmapping.lisp.util.ByteUtil;
+import org.opendaylight.lispflowmapping.lisp.util.NumberUtil;
import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.control.plane.rev150314.MapReply;
import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.control.plane.rev150314.eidtolocatorrecords.EidToLocatorRecord;
import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.control.plane.rev150314.eidtolocatorrecords.EidToLocatorRecordBuilder;
* 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.lispflowmapping.implementation.serializer;
+package org.opendaylight.lispflowmapping.lisp.serializer;
import java.nio.ByteBuffer;
import java.util.ArrayList;
import org.apache.commons.lang3.BooleanUtils;
-import org.opendaylight.lispflowmapping.implementation.lisp.exception.LispSerializationException;
-import org.opendaylight.lispflowmapping.implementation.serializer.address.LispAddressSerializer;
-import org.opendaylight.lispflowmapping.implementation.util.ByteUtil;
-import org.opendaylight.lispflowmapping.implementation.util.LispAFIConvertor;
-import org.opendaylight.lispflowmapping.implementation.util.NumberUtil;
+import org.opendaylight.lispflowmapping.lisp.serializer.address.LispAddressSerializer;
+import org.opendaylight.lispflowmapping.lisp.serializer.exception.LispSerializationException;
+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.NumberUtil;
import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.control.plane.rev150314.MapRequest;
import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.control.plane.rev150314.eidrecords.EidRecord;
import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.control.plane.rev150314.eidtolocatorrecords.EidToLocatorRecordBuilder;
* 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.lispflowmapping.implementation.serializer.address;
+package org.opendaylight.lispflowmapping.lisp.serializer.address;
import java.nio.ByteBuffer;
-import org.opendaylight.lispflowmapping.implementation.lisp.exception.LispSerializationException;
-import org.opendaylight.lispflowmapping.implementation.serializer.address.factory.LispAFIAddressSerializerFactory;
-import org.opendaylight.lispflowmapping.type.AddressFamilyNumberEnum;
+import org.opendaylight.lispflowmapping.lisp.serializer.address.factory.LispAFIAddressSerializerFactory;
+import org.opendaylight.lispflowmapping.lisp.serializer.exception.LispSerializationException;
+import org.opendaylight.lispflowmapping.lisp.type.AddressFamilyNumberEnum;
import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.control.plane.rev150314.LispAFIAddress;
public class LispAddressSerializer {
* 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.lispflowmapping.implementation.serializer.address;
+package org.opendaylight.lispflowmapping.lisp.serializer.address;
import java.nio.ByteBuffer;
-import org.opendaylight.lispflowmapping.implementation.util.ByteUtil;
-import org.opendaylight.lispflowmapping.implementation.util.LispAFIConvertor;
-import org.opendaylight.lispflowmapping.implementation.util.NumberUtil;
-import org.opendaylight.lispflowmapping.type.AddressFamilyNumberEnum;
-import org.opendaylight.lispflowmapping.type.LispCanonicalAddressFormatEnum;
+import org.opendaylight.lispflowmapping.lisp.type.AddressFamilyNumberEnum;
+import org.opendaylight.lispflowmapping.lisp.type.LispCanonicalAddressFormatEnum;
+import org.opendaylight.lispflowmapping.lisp.util.ByteUtil;
+import org.opendaylight.lispflowmapping.lisp.util.LispAFIConvertor;
+import org.opendaylight.lispflowmapping.lisp.util.NumberUtil;
import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.control.plane.rev150314.LcafApplicationDataAddress;
import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.control.plane.rev150314.LispAFIAddress;
import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.control.plane.rev150314.lcafapplicationdataaddress.AddressBuilder;
* 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.lispflowmapping.implementation.serializer.address;
+package org.opendaylight.lispflowmapping.lisp.serializer.address;
import java.nio.ByteBuffer;
-import org.opendaylight.lispflowmapping.type.AddressFamilyNumberEnum;
+import org.opendaylight.lispflowmapping.lisp.type.AddressFamilyNumberEnum;
import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.control.plane.rev150314.LispAFIAddress;
import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.control.plane.rev150314.LispDistinguishedNameAddress;
import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.control.plane.rev150314.lispaddress.lispaddresscontainer.address.distinguishedname.DistinguishedNameBuilder;
* 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.lispflowmapping.implementation.serializer.address;
+package org.opendaylight.lispflowmapping.lisp.serializer.address;
import java.net.Inet4Address;
import java.net.InetAddress;
import java.net.UnknownHostException;
import java.nio.ByteBuffer;
-import org.opendaylight.lispflowmapping.type.AddressFamilyNumberEnum;
+import org.opendaylight.lispflowmapping.lisp.type.AddressFamilyNumberEnum;
import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.control.plane.rev150314.LispAFIAddress;
import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.control.plane.rev150314.LispIpv4Address;
import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.control.plane.rev150314.lispaddress.lispaddresscontainer.address.ipv4.Ipv4AddressBuilder;
* 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.lispflowmapping.implementation.serializer.address;
+package org.opendaylight.lispflowmapping.lisp.serializer.address;
import java.net.Inet6Address;
import java.net.InetAddress;
import java.net.UnknownHostException;
import java.nio.ByteBuffer;
-import org.opendaylight.lispflowmapping.type.AddressFamilyNumberEnum;
+import org.opendaylight.lispflowmapping.lisp.type.AddressFamilyNumberEnum;
import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.control.plane.rev150314.LispAFIAddress;
import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.control.plane.rev150314.LispIpv6Address;
import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.control.plane.rev150314.lispaddress.lispaddresscontainer.address.ipv6.Ipv6AddressBuilder;
* 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.lispflowmapping.implementation.serializer.address;
+package org.opendaylight.lispflowmapping.lisp.serializer.address;
import java.nio.ByteBuffer;
-import org.opendaylight.lispflowmapping.implementation.util.LispAFIConvertor;
-import org.opendaylight.lispflowmapping.type.AddressFamilyNumberEnum;
-import org.opendaylight.lispflowmapping.type.LispCanonicalAddressFormatEnum;
+import org.opendaylight.lispflowmapping.lisp.type.AddressFamilyNumberEnum;
+import org.opendaylight.lispflowmapping.lisp.type.LispCanonicalAddressFormatEnum;
+import org.opendaylight.lispflowmapping.lisp.util.LispAFIConvertor;
import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.control.plane.rev150314.LcafKeyValueAddress;
import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.control.plane.rev150314.LispAFIAddress;
import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.control.plane.rev150314.lcafkeyvalueaddress.KeyBuilder;
* 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.lispflowmapping.implementation.serializer.address;
+package org.opendaylight.lispflowmapping.lisp.serializer.address;
import java.nio.ByteBuffer;
-import org.opendaylight.lispflowmapping.implementation.lisp.exception.LispSerializationException;
-import org.opendaylight.lispflowmapping.implementation.serializer.address.factory.LispLCAFAddressSerializerFactory;
-import org.opendaylight.lispflowmapping.implementation.util.ByteUtil;
-import org.opendaylight.lispflowmapping.type.LispCanonicalAddressFormatEnum;
+import org.opendaylight.lispflowmapping.lisp.serializer.address.factory.LispLCAFAddressSerializerFactory;
+import org.opendaylight.lispflowmapping.lisp.serializer.exception.LispSerializationException;
+import org.opendaylight.lispflowmapping.lisp.type.LispCanonicalAddressFormatEnum;
+import org.opendaylight.lispflowmapping.lisp.util.ByteUtil;
import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.control.plane.rev150314.LispAFIAddress;
import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.control.plane.rev150314.LispLcafAddress;
* 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.lispflowmapping.implementation.serializer.address;
+package org.opendaylight.lispflowmapping.lisp.serializer.address;
import java.nio.ByteBuffer;
import java.util.ArrayList;
import java.util.List;
-import org.opendaylight.lispflowmapping.implementation.util.LispAFIConvertor;
-import org.opendaylight.lispflowmapping.type.AddressFamilyNumberEnum;
-import org.opendaylight.lispflowmapping.type.LispCanonicalAddressFormatEnum;
+import org.opendaylight.lispflowmapping.lisp.type.AddressFamilyNumberEnum;
+import org.opendaylight.lispflowmapping.lisp.type.LispCanonicalAddressFormatEnum;
+import org.opendaylight.lispflowmapping.lisp.util.LispAFIConvertor;
import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.control.plane.rev150314.LcafListAddress;
import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.control.plane.rev150314.LispAFIAddress;
import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.control.plane.rev150314.lcaflistaddress.Addresses;
* 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.lispflowmapping.implementation.serializer.address;
+package org.opendaylight.lispflowmapping.lisp.serializer.address;
import java.nio.ByteBuffer;
* 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.lispflowmapping.implementation.serializer.address;
+package org.opendaylight.lispflowmapping.lisp.serializer.address;
import java.nio.ByteBuffer;
-import org.opendaylight.lispflowmapping.type.AddressFamilyNumberEnum;
+import org.opendaylight.lispflowmapping.lisp.type.AddressFamilyNumberEnum;
import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.control.plane.rev150314.LispAFIAddress;
import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.control.plane.rev150314.LispNoAddress;
import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.control.plane.rev150314.lispaddress.lispaddresscontainer.address.no.NoAddressBuilder;
* 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.lispflowmapping.implementation.serializer.address;
+package org.opendaylight.lispflowmapping.lisp.serializer.address;
import java.nio.ByteBuffer;
-import org.opendaylight.lispflowmapping.implementation.lisp.exception.LispSerializationException;
-import org.opendaylight.lispflowmapping.implementation.util.ByteUtil;
-import org.opendaylight.lispflowmapping.implementation.util.LispAFIConvertor;
-import org.opendaylight.lispflowmapping.type.AddressFamilyNumberEnum;
-import org.opendaylight.lispflowmapping.type.LispCanonicalAddressFormatEnum;
+import org.opendaylight.lispflowmapping.lisp.serializer.exception.LispSerializationException;
+import org.opendaylight.lispflowmapping.lisp.type.AddressFamilyNumberEnum;
+import org.opendaylight.lispflowmapping.lisp.type.LispCanonicalAddressFormatEnum;
+import org.opendaylight.lispflowmapping.lisp.util.ByteUtil;
+import org.opendaylight.lispflowmapping.lisp.util.LispAFIConvertor;
import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.control.plane.rev150314.LcafSegmentAddress;
import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.control.plane.rev150314.LispAFIAddress;
import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.control.plane.rev150314.lcafsegmentaddress.AddressBuilder;
* 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.lispflowmapping.implementation.serializer.address;
+package org.opendaylight.lispflowmapping.lisp.serializer.address;
import java.nio.ByteBuffer;
-import org.opendaylight.lispflowmapping.implementation.util.ByteUtil;
-import org.opendaylight.lispflowmapping.implementation.util.LispAFIConvertor;
-import org.opendaylight.lispflowmapping.type.AddressFamilyNumberEnum;
-import org.opendaylight.lispflowmapping.type.LispCanonicalAddressFormatEnum;
+import org.opendaylight.lispflowmapping.lisp.type.AddressFamilyNumberEnum;
+import org.opendaylight.lispflowmapping.lisp.type.LispCanonicalAddressFormatEnum;
+import org.opendaylight.lispflowmapping.lisp.util.ByteUtil;
+import org.opendaylight.lispflowmapping.lisp.util.LispAFIConvertor;
import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.control.plane.rev150314.LcafSourceDestAddress;
import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.control.plane.rev150314.LispAFIAddress;
import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.control.plane.rev150314.lcafsourcedestaddress.DstAddressBuilder;
* 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.lispflowmapping.implementation.serializer.address;
+package org.opendaylight.lispflowmapping.lisp.serializer.address;
import java.nio.ByteBuffer;
import java.util.ArrayList;
import java.util.List;
import org.apache.commons.lang3.BooleanUtils;
-import org.opendaylight.lispflowmapping.implementation.util.ByteUtil;
-import org.opendaylight.lispflowmapping.implementation.util.LispAFIConvertor;
-import org.opendaylight.lispflowmapping.type.AddressFamilyNumberEnum;
-import org.opendaylight.lispflowmapping.type.LispCanonicalAddressFormatEnum;
+import org.opendaylight.lispflowmapping.lisp.type.AddressFamilyNumberEnum;
+import org.opendaylight.lispflowmapping.lisp.type.LispCanonicalAddressFormatEnum;
+import org.opendaylight.lispflowmapping.lisp.util.ByteUtil;
+import org.opendaylight.lispflowmapping.lisp.util.LispAFIConvertor;
import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.control.plane.rev150314.LcafTrafficEngineeringAddress;
import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.control.plane.rev150314.LispAFIAddress;
import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.control.plane.rev150314.lcaftrafficengineeringaddress.Hops;
* 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.lispflowmapping.implementation.serializer.address.factory;
+package org.opendaylight.lispflowmapping.lisp.serializer.address.factory;
import java.util.HashMap;
import java.util.Map;
-import org.opendaylight.lispflowmapping.implementation.serializer.address.LispAddressSerializer;
-import org.opendaylight.lispflowmapping.implementation.serializer.address.LispDistinguishedNameAddressSerializer;
-import org.opendaylight.lispflowmapping.implementation.serializer.address.LispIpv4AddressSerializer;
-import org.opendaylight.lispflowmapping.implementation.serializer.address.LispIpv6AddressSerializer;
-import org.opendaylight.lispflowmapping.implementation.serializer.address.LispLCAFAddressSerializer;
-import org.opendaylight.lispflowmapping.implementation.serializer.address.LispMACAddressSerializer;
-import org.opendaylight.lispflowmapping.implementation.serializer.address.LispNoAddressSerializer;
-import org.opendaylight.lispflowmapping.type.AddressFamilyNumberEnum;
+import org.opendaylight.lispflowmapping.lisp.serializer.address.LispAddressSerializer;
+import org.opendaylight.lispflowmapping.lisp.serializer.address.LispDistinguishedNameAddressSerializer;
+import org.opendaylight.lispflowmapping.lisp.serializer.address.LispIpv4AddressSerializer;
+import org.opendaylight.lispflowmapping.lisp.serializer.address.LispIpv6AddressSerializer;
+import org.opendaylight.lispflowmapping.lisp.serializer.address.LispLCAFAddressSerializer;
+import org.opendaylight.lispflowmapping.lisp.serializer.address.LispMACAddressSerializer;
+import org.opendaylight.lispflowmapping.lisp.serializer.address.LispNoAddressSerializer;
+import org.opendaylight.lispflowmapping.lisp.type.AddressFamilyNumberEnum;
public class LispAFIAddressSerializerFactory {
* 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.lispflowmapping.implementation.serializer.address.factory;
+package org.opendaylight.lispflowmapping.lisp.serializer.address.factory;
import java.util.HashMap;
import java.util.Map;
-import org.opendaylight.lispflowmapping.implementation.serializer.address.LispApplicationDataLCAFAddressSerializer;
-import org.opendaylight.lispflowmapping.implementation.serializer.address.LispKeyValueLCAFSerializer;
-import org.opendaylight.lispflowmapping.implementation.serializer.address.LispLCAFAddressSerializer;
-import org.opendaylight.lispflowmapping.implementation.serializer.address.LispListLCAFAddressSerializer;
-import org.opendaylight.lispflowmapping.implementation.serializer.address.LispSegmentLCAFAddressSerializer;
-import org.opendaylight.lispflowmapping.implementation.serializer.address.LispSourceDestLCAFAddressSerializer;
-import org.opendaylight.lispflowmapping.implementation.serializer.address.LispTrafficEngineeringLCAFAddressSerializer;
-import org.opendaylight.lispflowmapping.type.LispCanonicalAddressFormatEnum;
+import org.opendaylight.lispflowmapping.lisp.serializer.address.LispApplicationDataLCAFAddressSerializer;
+import org.opendaylight.lispflowmapping.lisp.serializer.address.LispKeyValueLCAFSerializer;
+import org.opendaylight.lispflowmapping.lisp.serializer.address.LispLCAFAddressSerializer;
+import org.opendaylight.lispflowmapping.lisp.serializer.address.LispListLCAFAddressSerializer;
+import org.opendaylight.lispflowmapping.lisp.serializer.address.LispSegmentLCAFAddressSerializer;
+import org.opendaylight.lispflowmapping.lisp.serializer.address.LispSourceDestLCAFAddressSerializer;
+import org.opendaylight.lispflowmapping.lisp.serializer.address.LispTrafficEngineeringLCAFAddressSerializer;
+import org.opendaylight.lispflowmapping.lisp.type.LispCanonicalAddressFormatEnum;
public class LispLCAFAddressSerializerFactory {
* 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.lispflowmapping.implementation.lisp.exception;
+package org.opendaylight.lispflowmapping.lisp.serializer.exception;
public class LispSerializationException extends RuntimeException {
* and is available at http://www.eclipse.org/legal/epl-v10.html
*/
-package org.opendaylight.lispflowmapping.type;
+package org.opendaylight.lispflowmapping.lisp.type;
/**
* The AFI enum:
* and is available at http://www.eclipse.org/legal/epl-v10.html
*/
-package org.opendaylight.lispflowmapping.type;
+package org.opendaylight.lispflowmapping.lisp.type;
/**
* The LCAF enum. http://tools.ietf.org/html/draft-ietf-lisp-lcaf-03
* and is available at http://www.eclipse.org/legal/epl-v10.html
*/
-package org.opendaylight.lispflowmapping.implementation.serializer;
+package org.opendaylight.lispflowmapping.lisp.type;
public interface LispMessage {
int PORT_NUM = 4342;
* and is available at http://www.eclipse.org/legal/epl-v10.html
*/
-package org.opendaylight.lispflowmapping.implementation.serializer;
+package org.opendaylight.lispflowmapping.lisp.type;
public enum LispMessageEnum {
MapRequest((byte) 1), //
* and is available at http://www.eclipse.org/legal/epl-v10.html
*/
-package org.opendaylight.lispflowmapping.implementation.util;
+package org.opendaylight.lispflowmapping.lisp.util;
import java.nio.ByteBuffer;
* 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.lispflowmapping.implementation.util;
+package org.opendaylight.lispflowmapping.lisp.util;
import java.net.Inet4Address;
import java.net.Inet6Address;
import java.net.InetAddress;
-import org.opendaylight.lispflowmapping.type.AddressFamilyNumberEnum;
-import org.opendaylight.lispflowmapping.type.LispCanonicalAddressFormatEnum;
+import org.opendaylight.lispflowmapping.lisp.type.AddressFamilyNumberEnum;
+import org.opendaylight.lispflowmapping.lisp.type.LispCanonicalAddressFormatEnum;
import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.control.plane.rev150314.LispAFIAddress;
import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.control.plane.rev150314.lcafkeyvalueaddress.KeyBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.control.plane.rev150314.lcafkeyvalueaddress.ValueBuilder;
* 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.lispflowmapping.implementation.util;
+package org.opendaylight.lispflowmapping.lisp.util;
import java.util.List;
* 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.lispflowmapping.implementation.util;
+package org.opendaylight.lispflowmapping.lisp.util;
-import org.opendaylight.lispflowmapping.implementation.util.LispAddressStringifier.Destination;
+import org.opendaylight.lispflowmapping.lisp.util.LispAddressStringifier.Destination;
import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.control.plane.rev150314.lispsimpleaddress.PrimitiveAddress;
import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.control.plane.rev150314.lispsimpleaddress.primitiveaddress.AS;
import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.control.plane.rev150314.lispsimpleaddress.primitiveaddress.DistinguishedName;
* 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.lispflowmapping.implementation.util;
+package org.opendaylight.lispflowmapping.lisp.util;
import java.util.ArrayList;
import java.util.Arrays;
* 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.lispflowmapping.implementation.util;
+package org.opendaylight.lispflowmapping.lisp.util;
import java.net.InetAddress;
import java.net.UnknownHostException;
+import java.util.ArrayList;
+import java.util.Random;
import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.control.plane.rev150314.MapRequest;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.control.plane.rev150314.lispaddress.LispAddressContainer;
import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.control.plane.rev150314.lispaddress.lispaddresscontainer.Address;
import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.control.plane.rev150314.lispaddress.lispaddresscontainer.address.Ipv4;
import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.control.plane.rev150314.lispaddress.lispaddresscontainer.address.Ipv6;
import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.control.plane.rev150314.maprequest.ItrRloc;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.control.plane.rev150314.maprequest.ItrRlocBuilder;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.control.plane.rev150314.maprequest.SourceEidBuilder;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.control.plane.rev150314.maprequestnotification.MapRequestBuilder;
public class MapRequestUtil {
public static InetAddress selectItrRloc(MapRequest request) {
}
return selectedItrRloc;
}
+
+ public static MapRequestBuilder prepareSMR(LispAddressContainer srcEid, LispAddressContainer itrRloc) {
+ MapRequestBuilder builder = new MapRequestBuilder();
+ builder.setAuthoritative(false);
+ builder.setMapDataPresent(false);
+ builder.setPitr(false);
+ builder.setProbe(false);
+ builder.setSmr(true);
+ builder.setSmrInvoked(false);
+
+ builder.setSourceEid(new SourceEidBuilder().setLispAddressContainer(srcEid).build());
+ builder.setItrRloc(new ArrayList<ItrRloc>());
+ builder.getItrRloc().add(new ItrRlocBuilder().setLispAddressContainer(itrRloc).build());
+ builder.setMapReply(null);
+ builder.setNonce(new Random().nextLong());
+
+ return builder;
+ }
+
}
* 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.lispflowmapping.implementation.util;
+package org.opendaylight.lispflowmapping.lisp.util;
import java.util.ArrayList;
import java.util.List;
* 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.lispflowmapping.implementation.util;
+package org.opendaylight.lispflowmapping.lisp.util;
public class NumberUtil {
* and is available at http://www.eclipse.org/legal/epl-v10.html
*/
-package org.opendaylight.lispflowmapping.implementation.serializer;
+package org.opendaylight.lispflowmapping.serializer;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertFalse;
import junitx.framework.ArrayAssert;
import org.junit.Test;
-import org.opendaylight.lispflowmapping.implementation.lisp.exception.LispSerializationException;
-import org.opendaylight.lispflowmapping.implementation.util.LispAFIConvertor;
+import org.opendaylight.lispflowmapping.lisp.serializer.MapNotifySerializer;
+import org.opendaylight.lispflowmapping.lisp.serializer.exception.LispSerializationException;
+import org.opendaylight.lispflowmapping.lisp.type.AddressFamilyNumberEnum;
+import org.opendaylight.lispflowmapping.lisp.util.LispAFIConvertor;
import org.opendaylight.lispflowmapping.tools.junit.BaseTestCase;
-import org.opendaylight.lispflowmapping.type.AddressFamilyNumberEnum;
import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.control.plane.rev150314.EidToLocatorRecord.Action;
import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.control.plane.rev150314.MapNotify;
import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.control.plane.rev150314.eidtolocatorrecords.EidToLocatorRecord;
* and is available at http://www.eclipse.org/legal/epl-v10.html
*/
-package org.opendaylight.lispflowmapping.implementation.serializer;
+package org.opendaylight.lispflowmapping.serializer;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertFalse;
import junitx.framework.ArrayAssert;
import org.junit.Test;
-import org.opendaylight.lispflowmapping.implementation.lisp.exception.LispSerializationException;
-import org.opendaylight.lispflowmapping.implementation.serializer.MapRegisterSerializer.Length;
-import org.opendaylight.lispflowmapping.implementation.util.LispAFIConvertor;
+import org.opendaylight.lispflowmapping.lisp.serializer.MapRegisterSerializer;
+import org.opendaylight.lispflowmapping.lisp.serializer.MapRegisterSerializer.Length;
+import org.opendaylight.lispflowmapping.lisp.serializer.exception.LispSerializationException;
+import org.opendaylight.lispflowmapping.lisp.type.AddressFamilyNumberEnum;
+import org.opendaylight.lispflowmapping.lisp.util.LispAFIConvertor;
import org.opendaylight.lispflowmapping.tools.junit.BaseTestCase;
-import org.opendaylight.lispflowmapping.type.AddressFamilyNumberEnum;
import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.control.plane.rev150314.EidToLocatorRecord.Action;
import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.control.plane.rev150314.MapRegister;
import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.control.plane.rev150314.eidtolocatorrecords.EidToLocatorRecord;
* and is available at http://www.eclipse.org/legal/epl-v10.html
*/
-package org.opendaylight.lispflowmapping.implementation.serializer;
+package org.opendaylight.lispflowmapping.serializer;
import static org.junit.Assert.assertEquals;
import org.junit.Ignore;
import org.junit.Test;
-import org.opendaylight.lispflowmapping.implementation.util.LispAFIConvertor;
+import org.opendaylight.lispflowmapping.lisp.serializer.MapReplySerializer;
+import org.opendaylight.lispflowmapping.lisp.util.LispAFIConvertor;
import org.opendaylight.lispflowmapping.tools.junit.BaseTestCase;
import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.control.plane.rev150314.EidToLocatorRecord.Action;
import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.control.plane.rev150314.MapReply;
* and is available at http://www.eclipse.org/legal/epl-v10.html
*/
-package org.opendaylight.lispflowmapping.implementation.serializer;
+package org.opendaylight.lispflowmapping.serializer;
import static org.junit.Assert.assertArrayEquals;
import static org.junit.Assert.assertEquals;
import java.util.ArrayList;
import org.junit.Test;
-import org.opendaylight.lispflowmapping.implementation.util.LispAFIConvertor;
+import org.opendaylight.lispflowmapping.lisp.serializer.MapRequestSerializer;
+import org.opendaylight.lispflowmapping.lisp.type.AddressFamilyNumberEnum;
+import org.opendaylight.lispflowmapping.lisp.util.LispAFIConvertor;
import org.opendaylight.lispflowmapping.tools.junit.BaseTestCase;
-import org.opendaylight.lispflowmapping.type.AddressFamilyNumberEnum;
import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.control.plane.rev150314.EidToLocatorRecord.Action;
import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.control.plane.rev150314.MapRequest;
import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.control.plane.rev150314.eidrecords.EidRecord;
* 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.lispflowmapping.implementation.serializer.address;
+package org.opendaylight.lispflowmapping.serializer.address;
import static org.junit.Assert.assertEquals;
import junitx.framework.ArrayAssert;
import org.junit.Test;
-import org.opendaylight.lispflowmapping.implementation.lisp.exception.LispSerializationException;
-import org.opendaylight.lispflowmapping.implementation.util.ByteUtil;
-import org.opendaylight.lispflowmapping.implementation.util.LispAFIConvertor;
+import org.opendaylight.lispflowmapping.lisp.serializer.address.LispAddressSerializer;
+import org.opendaylight.lispflowmapping.lisp.serializer.exception.LispSerializationException;
+import org.opendaylight.lispflowmapping.lisp.type.AddressFamilyNumberEnum;
+import org.opendaylight.lispflowmapping.lisp.type.LispCanonicalAddressFormatEnum;
+import org.opendaylight.lispflowmapping.lisp.util.ByteUtil;
+import org.opendaylight.lispflowmapping.lisp.util.LispAFIConvertor;
import org.opendaylight.lispflowmapping.tools.junit.BaseTestCase;
-import org.opendaylight.lispflowmapping.type.AddressFamilyNumberEnum;
-import org.opendaylight.lispflowmapping.type.LispCanonicalAddressFormatEnum;
import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.control.plane.rev150314.LcafApplicationDataAddress;
import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.control.plane.rev150314.LispAFIAddress;
import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.control.plane.rev150314.lcafapplicationdataaddress.AddressBuilder;
* 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.lispflowmapping.implementation.serializer.address;
+package org.opendaylight.lispflowmapping.serializer.address;
import static org.junit.Assert.assertEquals;
import junitx.framework.ArrayAssert;
import org.junit.Test;
-import org.opendaylight.lispflowmapping.implementation.lisp.exception.LispSerializationException;
-import org.opendaylight.lispflowmapping.implementation.util.LispAFIConvertor;
+import org.opendaylight.lispflowmapping.lisp.serializer.address.LispAddressSerializer;
+import org.opendaylight.lispflowmapping.lisp.serializer.exception.LispSerializationException;
+import org.opendaylight.lispflowmapping.lisp.type.AddressFamilyNumberEnum;
+import org.opendaylight.lispflowmapping.lisp.type.LispCanonicalAddressFormatEnum;
+import org.opendaylight.lispflowmapping.lisp.util.LispAFIConvertor;
import org.opendaylight.lispflowmapping.tools.junit.BaseTestCase;
-import org.opendaylight.lispflowmapping.type.AddressFamilyNumberEnum;
-import org.opendaylight.lispflowmapping.type.LispCanonicalAddressFormatEnum;
import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.control.plane.rev150314.LcafListAddress;
import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.control.plane.rev150314.LispAFIAddress;
import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.control.plane.rev150314.LispDistinguishedNameAddress;
* and is available at http://www.eclipse.org/legal/epl-v10.html
*/
-package org.opendaylight.lispflowmapping.implementation.serializer.address;
+package org.opendaylight.lispflowmapping.serializer.address;
import static org.junit.Assert.assertEquals;
import org.junit.Test;
-import org.opendaylight.lispflowmapping.implementation.util.LispAFIConvertor;
+import org.opendaylight.lispflowmapping.lisp.serializer.address.LispAddressSerializer;
+import org.opendaylight.lispflowmapping.lisp.type.AddressFamilyNumberEnum;
+import org.opendaylight.lispflowmapping.lisp.util.LispAFIConvertor;
import org.opendaylight.lispflowmapping.tools.junit.BaseTestCase;
-import org.opendaylight.lispflowmapping.type.AddressFamilyNumberEnum;
import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.control.plane.rev150314.lispaddress.lispaddresscontainer.address.ipv6.Ipv6Address;
public class LispIpv6AddressTest extends BaseTestCase {
* 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.lispflowmapping.implementation.serializer.address;
+package org.opendaylight.lispflowmapping.serializer.address;
import static org.junit.Assert.assertEquals;
import junitx.framework.ArrayAssert;
import org.junit.Test;
-import org.opendaylight.lispflowmapping.implementation.lisp.exception.LispSerializationException;
-import org.opendaylight.lispflowmapping.implementation.util.LispAFIConvertor;
+import org.opendaylight.lispflowmapping.lisp.serializer.address.LispAddressSerializer;
+import org.opendaylight.lispflowmapping.lisp.serializer.exception.LispSerializationException;
+import org.opendaylight.lispflowmapping.lisp.type.AddressFamilyNumberEnum;
+import org.opendaylight.lispflowmapping.lisp.type.LispCanonicalAddressFormatEnum;
+import org.opendaylight.lispflowmapping.lisp.util.LispAFIConvertor;
import org.opendaylight.lispflowmapping.tools.junit.BaseTestCase;
-import org.opendaylight.lispflowmapping.type.AddressFamilyNumberEnum;
-import org.opendaylight.lispflowmapping.type.LispCanonicalAddressFormatEnum;
import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.control.plane.rev150314.LcafKeyValueAddress;
import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.control.plane.rev150314.LispAFIAddress;
import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.control.plane.rev150314.lcafkeyvalueaddress.KeyBuilder;
* 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.lispflowmapping.implementation.serializer.address;
+package org.opendaylight.lispflowmapping.serializer.address;
import static org.junit.Assert.assertEquals;
import junitx.framework.Assert;
import org.junit.Test;
-import org.opendaylight.lispflowmapping.implementation.lisp.exception.LispSerializationException;
-import org.opendaylight.lispflowmapping.implementation.util.LispAFIConvertor;
+import org.opendaylight.lispflowmapping.lisp.serializer.address.LispAddressSerializer;
+import org.opendaylight.lispflowmapping.lisp.serializer.exception.LispSerializationException;
+import org.opendaylight.lispflowmapping.lisp.type.AddressFamilyNumberEnum;
+import org.opendaylight.lispflowmapping.lisp.type.LispCanonicalAddressFormatEnum;
+import org.opendaylight.lispflowmapping.lisp.util.LispAFIConvertor;
import org.opendaylight.lispflowmapping.tools.junit.BaseTestCase;
-import org.opendaylight.lispflowmapping.type.AddressFamilyNumberEnum;
-import org.opendaylight.lispflowmapping.type.LispCanonicalAddressFormatEnum;
import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.control.plane.rev150314.LcafListAddress;
import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.control.plane.rev150314.LispAFIAddress;
import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.control.plane.rev150314.lcaflistaddress.Addresses;
* 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.lispflowmapping.implementation.serializer.address;
+package org.opendaylight.lispflowmapping.serializer.address;
import static org.junit.Assert.assertEquals;
import junitx.framework.ArrayAssert;
import org.junit.Test;
-import org.opendaylight.lispflowmapping.implementation.lisp.exception.LispSerializationException;
-import org.opendaylight.lispflowmapping.implementation.util.LispAFIConvertor;
+import org.opendaylight.lispflowmapping.lisp.serializer.address.LispAddressSerializer;
+import org.opendaylight.lispflowmapping.lisp.serializer.exception.LispSerializationException;
+import org.opendaylight.lispflowmapping.lisp.type.AddressFamilyNumberEnum;
+import org.opendaylight.lispflowmapping.lisp.type.LispCanonicalAddressFormatEnum;
+import org.opendaylight.lispflowmapping.lisp.util.LispAFIConvertor;
import org.opendaylight.lispflowmapping.tools.junit.BaseTestCase;
-import org.opendaylight.lispflowmapping.type.AddressFamilyNumberEnum;
-import org.opendaylight.lispflowmapping.type.LispCanonicalAddressFormatEnum;
import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.control.plane.rev150314.LcafSegmentAddress;
import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.control.plane.rev150314.LispAFIAddress;
import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.control.plane.rev150314.lcafsegmentaddress.AddressBuilder;
* 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.lispflowmapping.implementation.serializer.address;
+package org.opendaylight.lispflowmapping.serializer.address;
import static org.junit.Assert.assertEquals;
import junitx.framework.ArrayAssert;
import org.junit.Test;
-import org.opendaylight.lispflowmapping.implementation.lisp.exception.LispSerializationException;
-import org.opendaylight.lispflowmapping.implementation.util.LispAFIConvertor;
+import org.opendaylight.lispflowmapping.lisp.serializer.address.LispAddressSerializer;
+import org.opendaylight.lispflowmapping.lisp.serializer.exception.LispSerializationException;
+import org.opendaylight.lispflowmapping.lisp.type.AddressFamilyNumberEnum;
+import org.opendaylight.lispflowmapping.lisp.type.LispCanonicalAddressFormatEnum;
+import org.opendaylight.lispflowmapping.lisp.util.LispAFIConvertor;
import org.opendaylight.lispflowmapping.tools.junit.BaseTestCase;
-import org.opendaylight.lispflowmapping.type.AddressFamilyNumberEnum;
-import org.opendaylight.lispflowmapping.type.LispCanonicalAddressFormatEnum;
import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.control.plane.rev150314.LcafSourceDestAddress;
import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.control.plane.rev150314.LispAFIAddress;
import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.control.plane.rev150314.lcafsourcedestaddress.DstAddressBuilder;
* 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.lispflowmapping.implementation.serializer.address;
+package org.opendaylight.lispflowmapping.serializer.address;
import static org.junit.Assert.assertEquals;
import junitx.framework.ArrayAssert;
import org.junit.Test;
-import org.opendaylight.lispflowmapping.implementation.lisp.exception.LispSerializationException;
-import org.opendaylight.lispflowmapping.implementation.util.LispAFIConvertor;
+import org.opendaylight.lispflowmapping.lisp.serializer.address.LispAddressSerializer;
+import org.opendaylight.lispflowmapping.lisp.serializer.exception.LispSerializationException;
+import org.opendaylight.lispflowmapping.lisp.type.AddressFamilyNumberEnum;
+import org.opendaylight.lispflowmapping.lisp.type.LispCanonicalAddressFormatEnum;
+import org.opendaylight.lispflowmapping.lisp.util.LispAFIConvertor;
import org.opendaylight.lispflowmapping.tools.junit.BaseTestCase;
-import org.opendaylight.lispflowmapping.type.AddressFamilyNumberEnum;
-import org.opendaylight.lispflowmapping.type.LispCanonicalAddressFormatEnum;
import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.control.plane.rev150314.LcafTrafficEngineeringAddress;
import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.control.plane.rev150314.LispAFIAddress;
import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.control.plane.rev150314.lcaftrafficengineeringaddress.Hops;
Code Review / lispflowmapping.git / commitdiff