From 970c3dbd56428e43f2c13f7c2fdb13dd0696aeaf Mon Sep 17 00:00:00 2001 From: Florin Coras Date: Sun, 23 Aug 2015 17:48:30 +0200 Subject: [PATCH] Update DAO API The changes are meant to simplify the interaction between Map-Server/Map-Resolver and DAO but also to avoid expensive data types conversions. Most notable: - Use LispAddressContainer instead of IMappingKey as key for DAO. This required updating IPv4 and IPv6 addresses, as modeled in lisp-proto.yang, to include mask length, needed for longest prefix matches. Additionally, 1) for southbound messages, deserializers had to be updated to ensure that mask lengths of deserialized EIDs reflect the values set in the corresponding LISP messages fields 2) RPC handler methods had to be updated to ensure EID mask lengths are equal to those set in RPC input objects. - EidToLocatorRecord is used as value in DAO instead of RLOCGroup. This avoids data type conversions when storing and retrieving mappings (Map-Register/Map-Reply) but also ensures that the matched EIDs are implicitly returned with each lookup. This avoids the overhead associated to building on the fly EID-to-RLOCGroup pairing, because of longest prefix matching requirements. - Rename DAOMappingUtil to TopologyMapCache and cleanup of map-cache lookup logic - Introduce new DAO API method for building nested DAOs. Since this acts as a factory method, it also avoids TopologyMapCache dependence on DAO implementation. Change-Id: I1ef9c256fc0bf86d82de4d3d1473e7decd47a9e4 Signed-off-by: Florin Coras --- .../interfaces/dao/ILispDAO.java | 10 + .../interfaces/dao/IMappingKey.java | 28 - .../interfaces/dao/RLOCGroup.java | 127 ---- .../interfaces/dao/SubKeys.java | 25 + .../interfaces/lisp/IFlowMapping.java | 2 +- .../interfaces/lisp/IGeneralMapServer.java | 9 +- .../interfaces/lisp/IMapServerAsync.java | 2 +- .../clusterdao/ClusterDAOService.java | 22 +- mappingservice/implementation/pom.xml | 5 - .../implementation/LfmMappingDatabaseRpc.java | 52 +- .../implementation/LispMappingService.java | 67 +-- .../implementation/dao/MappingKey.java | 67 --- .../implementation/dao/MappingKeyUtil.java | 44 -- .../implementation/dao/MappingNoMaskKey.java | 67 --- .../implementation/lisp/MapResolver.java | 67 +-- .../implementation/lisp/MapServer.java | 96 +-- .../mapcache/TopologyMapCache.java | 282 +++++++++ .../mdsal/AuthenticationKeyDataListener.java | 8 +- .../mdsal/DataStoreBackEnd.java | 31 +- .../mdsal/MappingDataListener.java | 2 +- .../implementation/util/DAOMappingUtil.java | 549 ------------------ .../implementation/util/DAOSubKeys.java | 39 -- .../util/InstanceIdentifierUtil.java | 12 +- .../util/LispNotificationHelper.java | 2 +- .../implementation/util/MaskUtil.java | 108 ---- .../util/RPCInputConvertorUtil.java | 12 +- .../implementation/lisp/MapResolverTest.java | 135 ++--- .../implementation/lisp/MapServerTest.java | 332 ++++++----- .../lispflowmapping/inmemorydb/HashMapDb.java | 27 +- .../MappingServiceIntegrationTest.java | 49 +- .../lisp/serializer/EidRecordSerializer.java | 6 +- .../EidToLocatorRecordSerializer.java | 1 + .../lisp/serializer/SerializerHelper.java | 40 ++ .../LispSourceDestLCAFAddressSerializer.java | 7 +- .../lisp/util/LcafSourceDestHelper.java | 146 +++++ .../lisp/util/LispAFIConvertor.java | 100 +++- .../lisp/util/LispAddressStringifier.java | 33 +- .../lispflowmapping/lisp/util/MaskUtil.java | 308 ++++++++++ .../lisp-proto/src/main/yang/lisp-proto.yang | 6 + .../MapNotifySerializationTest.java | 4 +- .../MapRegisterSerializationTest.java | 4 +- .../serializer/MapReplySerializationTest.java | 12 +- .../MapRequestSerializationTest.java | 10 +- .../LispSourceDestLCAFAddressTest.java | 14 +- .../lisp/LispSouthboundServiceTest.java | 56 +- 45 files changed, 1411 insertions(+), 1614 deletions(-) delete mode 100644 mappingservice/api/src/main/java/org/opendaylight/lispflowmapping/interfaces/dao/IMappingKey.java delete mode 100644 mappingservice/api/src/main/java/org/opendaylight/lispflowmapping/interfaces/dao/RLOCGroup.java create mode 100644 mappingservice/api/src/main/java/org/opendaylight/lispflowmapping/interfaces/dao/SubKeys.java delete mode 100644 mappingservice/implementation/src/main/java/org/opendaylight/lispflowmapping/implementation/dao/MappingKey.java delete mode 100644 mappingservice/implementation/src/main/java/org/opendaylight/lispflowmapping/implementation/dao/MappingKeyUtil.java delete mode 100644 mappingservice/implementation/src/main/java/org/opendaylight/lispflowmapping/implementation/dao/MappingNoMaskKey.java create mode 100644 mappingservice/implementation/src/main/java/org/opendaylight/lispflowmapping/implementation/mapcache/TopologyMapCache.java delete mode 100644 mappingservice/implementation/src/main/java/org/opendaylight/lispflowmapping/implementation/util/DAOMappingUtil.java delete mode 100644 mappingservice/implementation/src/main/java/org/opendaylight/lispflowmapping/implementation/util/DAOSubKeys.java delete mode 100644 mappingservice/implementation/src/main/java/org/opendaylight/lispflowmapping/implementation/util/MaskUtil.java create mode 100644 mappingservice/lisp-proto/src/main/java/org/opendaylight/lispflowmapping/lisp/serializer/SerializerHelper.java create mode 100644 mappingservice/lisp-proto/src/main/java/org/opendaylight/lispflowmapping/lisp/util/LcafSourceDestHelper.java create mode 100644 mappingservice/lisp-proto/src/main/java/org/opendaylight/lispflowmapping/lisp/util/MaskUtil.java diff --git a/mappingservice/api/src/main/java/org/opendaylight/lispflowmapping/interfaces/dao/ILispDAO.java b/mappingservice/api/src/main/java/org/opendaylight/lispflowmapping/interfaces/dao/ILispDAO.java index 1bc7d1541..43fbba1d2 100644 --- a/mappingservice/api/src/main/java/org/opendaylight/lispflowmapping/interfaces/dao/ILispDAO.java +++ b/mappingservice/api/src/main/java/org/opendaylight/lispflowmapping/interfaces/dao/ILispDAO.java @@ -73,4 +73,14 @@ public interface ILispDAO { */ public void removeAll(); + /** + * Inserts a new, nested table for given key and subkey. Also acts as factory method. + * + * @param key + * The key for which a new table is linked in + * @param valueKey + * The subkey under which to insert the new table + * @return The inserted table + */ + public ILispDAO putNestedTable(Object key, String valueKey); } diff --git a/mappingservice/api/src/main/java/org/opendaylight/lispflowmapping/interfaces/dao/IMappingKey.java b/mappingservice/api/src/main/java/org/opendaylight/lispflowmapping/interfaces/dao/IMappingKey.java deleted file mode 100644 index c1747e530..000000000 --- a/mappingservice/api/src/main/java/org/opendaylight/lispflowmapping/interfaces/dao/IMappingKey.java +++ /dev/null @@ -1,28 +0,0 @@ -/* - * 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.interfaces.dao; - -import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev150820.lispaddress.LispAddressContainer; - -/** - * The mapping service key in the DAO. - */ -public interface IMappingKey { - - /** - * @return The eid of the key - */ - LispAddressContainer getEID(); - - /** - * @return The mask of the eid - */ - int getMask(); - -} diff --git a/mappingservice/api/src/main/java/org/opendaylight/lispflowmapping/interfaces/dao/RLOCGroup.java b/mappingservice/api/src/main/java/org/opendaylight/lispflowmapping/interfaces/dao/RLOCGroup.java deleted file mode 100644 index 9e6ec46d9..000000000 --- a/mappingservice/api/src/main/java/org/opendaylight/lispflowmapping/interfaces/dao/RLOCGroup.java +++ /dev/null @@ -1,127 +0,0 @@ -/* - * 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.interfaces.dao; - -import java.util.ArrayList; -import java.util.Date; -import java.util.List; - -import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev150820.EidToLocatorRecord.Action; -import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev150820.locatorrecords.LocatorRecord; - -/** - * A RLOC in the mapping service with it's properties. - */ -public class RLOCGroup { - - private List records; - private int ttl; - private Action action; - private boolean authoritative; - private Date registerdDate; - - public RLOCGroup(int ttl, Action action, boolean authoritative) { - this(ttl, action, authoritative, new Date(System.currentTimeMillis())); - } - - public RLOCGroup(int ttl, Action action, boolean authoritative, Date registerdDate) { - super(); - this.records = new ArrayList<>(); - this.ttl = ttl; - this.action = action; - this.authoritative = authoritative; - this.registerdDate = registerdDate; - } - - public List getRecords() { - return records; - } - - public RLOCGroup addRecord(LocatorRecord record) { - this.records.add(record); - return this; - } - - public int getTtl() { - return ttl; - } - - public RLOCGroup setTtl(int ttl) { - this.ttl = ttl; - return this; - } - - public Action getAction() { - return action; - } - - public RLOCGroup setAction(Action action) { - this.action = action; - return this; - } - - public boolean isAuthoritative() { - return authoritative; - } - - public RLOCGroup setAuthoritative(boolean authoritative) { - this.authoritative = authoritative; - return this; - } - - public Date getRegisterdDate() { - return registerdDate; - } - - public RLOCGroup setRegisterdDate(Date registerdDate) { - this.registerdDate = registerdDate; - return this; - } - - @Override - public int hashCode() { - final int prime = 31; - int result = 1; - result = prime * result + ((action == null) ? 0 : action.hashCode()); - result = prime * result + (authoritative ? 1231 : 1237); - result = prime * result + ((records == null) ? 0 : records.hashCode()); - result = prime * result + ((registerdDate == null) ? 0 : registerdDate.hashCode()); - result = prime * result + ttl; - return result; - } - - @Override - public boolean equals(Object obj) { - if (this == obj) - return true; - if (obj == null) - return false; - if (getClass() != obj.getClass()) - return false; - RLOCGroup other = (RLOCGroup) obj; - if (action != other.action) - return false; - if (authoritative != other.authoritative) - return false; - if (records == null) { - if (other.records != null) - return false; - } else if (!records.equals(other.records)) - return false; - if (ttl != other.ttl) - return false; - return true; - } - - @Override - public String toString() { - return "MappingServiceRLOCGroup [records=" + records + ", ttl=" + ttl + ", action=" + action + ", authoritative=" + authoritative - + ", registerdDate=" + registerdDate + "]"; - } - -} diff --git a/mappingservice/api/src/main/java/org/opendaylight/lispflowmapping/interfaces/dao/SubKeys.java b/mappingservice/api/src/main/java/org/opendaylight/lispflowmapping/interfaces/dao/SubKeys.java new file mode 100644 index 000000000..99bb06d15 --- /dev/null +++ b/mappingservice/api/src/main/java/org/opendaylight/lispflowmapping/interfaces/dao/SubKeys.java @@ -0,0 +1,25 @@ +/* + * 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.interfaces.dao; + +/** + * Defines DAO Subkeys + * + * @author Florin Coras + * + */ + +public interface SubKeys { + String PASSWORD = "password"; + String RECORD = "address"; + String SUBSCRIBERS = "subscribers"; + String REGDATE = "date"; + String LCAF_SRCDST = "lcaf_srcdst"; + String UNKOWN = "-1"; +} diff --git a/mappingservice/api/src/main/java/org/opendaylight/lispflowmapping/interfaces/lisp/IFlowMapping.java b/mappingservice/api/src/main/java/org/opendaylight/lispflowmapping/interfaces/lisp/IFlowMapping.java index 13d5572e0..4a515bf80 100644 --- a/mappingservice/api/src/main/java/org/opendaylight/lispflowmapping/interfaces/lisp/IFlowMapping.java +++ b/mappingservice/api/src/main/java/org/opendaylight/lispflowmapping/interfaces/lisp/IFlowMapping.java @@ -27,5 +27,5 @@ public interface IFlowMapping extends IMapResolver, IMapServer { public MapNotify handleMapRegister(MapRegister mb); public MapReply handleMapRequest(MapRequest mr); - public void removeMapping(LispAddressContainer address, int maskLen); + public void removeMapping(LispAddressContainer address); } diff --git a/mappingservice/api/src/main/java/org/opendaylight/lispflowmapping/interfaces/lisp/IGeneralMapServer.java b/mappingservice/api/src/main/java/org/opendaylight/lispflowmapping/interfaces/lisp/IGeneralMapServer.java index 1d0d19ce2..8f09081e3 100644 --- a/mappingservice/api/src/main/java/org/opendaylight/lispflowmapping/interfaces/lisp/IGeneralMapServer.java +++ b/mappingservice/api/src/main/java/org/opendaylight/lispflowmapping/interfaces/lisp/IGeneralMapServer.java @@ -33,10 +33,9 @@ public interface IGeneralMapServer { * This method returns the authentication key of the address. * * @param address EID to look up - * @param maskLen EID mask length * @return The correct key. */ - String getAuthenticationKey(LispAddressContainer address, int maskLen); + String getAuthenticationKey(LispAddressContainer address); void setShouldIterateMask(boolean shouldIterateMask); @@ -48,16 +47,14 @@ public interface IGeneralMapServer { * This method removes the given authentication key from the map server. * * @param address EID to remove - * @param maskLen EID mask length */ - void removeAuthenticationKey(LispAddressContainer address, int maskLen); + void removeAuthenticationKey(LispAddressContainer address); /** * This method adds an authentication key to the address. * * @param address EID to add - * @param maskLen EID mask length * @param key Value of the key for the EID */ - void addAuthenticationKey(LispAddressContainer address, int maskLen, String key); + void addAuthenticationKey(LispAddressContainer address, String key); } diff --git a/mappingservice/api/src/main/java/org/opendaylight/lispflowmapping/interfaces/lisp/IMapServerAsync.java b/mappingservice/api/src/main/java/org/opendaylight/lispflowmapping/interfaces/lisp/IMapServerAsync.java index 102533b3c..b49547556 100644 --- a/mappingservice/api/src/main/java/org/opendaylight/lispflowmapping/interfaces/lisp/IMapServerAsync.java +++ b/mappingservice/api/src/main/java/org/opendaylight/lispflowmapping/interfaces/lisp/IMapServerAsync.java @@ -15,6 +15,6 @@ import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev150820.li */ public interface IMapServerAsync extends IGeneralMapServer { public void handleMapRegister(MapRegister request, boolean smr, IMapNotifyHandler callback); - public void removeMapping(LispAddressContainer address, int maskLen, boolean smr, IMapNotifyHandler callback); + public void removeMapping(LispAddressContainer address, boolean smr, IMapNotifyHandler callback); } diff --git a/mappingservice/clusterdao/src/main/java/org/opendaylight/lispflowmapping/clusterdao/ClusterDAOService.java b/mappingservice/clusterdao/src/main/java/org/opendaylight/lispflowmapping/clusterdao/ClusterDAOService.java index 157b23f75..cc99576e2 100644 --- a/mappingservice/clusterdao/src/main/java/org/opendaylight/lispflowmapping/clusterdao/ClusterDAOService.java +++ b/mappingservice/clusterdao/src/main/java/org/opendaylight/lispflowmapping/clusterdao/ClusterDAOService.java @@ -8,6 +8,7 @@ package org.opendaylight.lispflowmapping.clusterdao; +import java.util.Date; import java.util.EnumSet; import java.util.Map; import java.util.concurrent.ConcurrentHashMap; @@ -23,7 +24,7 @@ import org.opendaylight.controller.clustering.services.IClusterServices; 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.RLOCGroup; +import org.opendaylight.lispflowmapping.interfaces.dao.SubKeys; import org.slf4j.Logger; import org.slf4j.LoggerFactory; @@ -106,19 +107,20 @@ public class ClusterDAOService implements ILispDAO { } } + // TODO: this should be moved outside of DAO implementation public void cleanOld() { getAll(new IRowVisitor() { public void visitRow(Object keyId, String valueKey, Object value) { - if (value instanceof RLOCGroup) { - RLOCGroup rloc = (RLOCGroup) value; - if (isExpired(rloc)) { - removeSpecific(keyId, valueKey); + if (value != null && valueKey instanceof String && ((String) valueKey).equals(SubKeys.REGDATE)) { + Date date = (Date) value; + if (isExpired(date)) { + removeSpecific(keyId, SubKeys.RECORD); } } } - private boolean isExpired(RLOCGroup rloc) { - return System.currentTimeMillis() - rloc.getRegisterdDate().getTime() > TimeUnit.MILLISECONDS.convert(recordTimeOut, timeUnit); + private boolean isExpired(Date date) { + return System.currentTimeMillis() - date.getTime() > TimeUnit.MILLISECONDS.convert(recordTimeOut, timeUnit); } }); } @@ -164,4 +166,10 @@ public class ClusterDAOService implements ILispDAO { public void setTimeUnit(TimeUnit timeUnit) { this.timeUnit = timeUnit; } + + @Override + public ILispDAO putNestedTable(Object key, String valueKey) { + // TODO Auto-generated method stub + return null; + } } diff --git a/mappingservice/implementation/pom.xml b/mappingservice/implementation/pom.xml index 2858465ab..b637bf172 100644 --- a/mappingservice/implementation/pom.xml +++ b/mappingservice/implementation/pom.xml @@ -18,11 +18,6 @@ mappingservice.api ${project.version} - - ${project.groupId} - mappingservice.inmemorydb - ${project.version} - ${project.groupId} mappingservice.lisp-proto diff --git a/mappingservice/implementation/src/main/java/org/opendaylight/lispflowmapping/implementation/LfmMappingDatabaseRpc.java b/mappingservice/implementation/src/main/java/org/opendaylight/lispflowmapping/implementation/LfmMappingDatabaseRpc.java index a540c00d3..1a6c69996 100644 --- a/mappingservice/implementation/src/main/java/org/opendaylight/lispflowmapping/implementation/LfmMappingDatabaseRpc.java +++ b/mappingservice/implementation/src/main/java/org/opendaylight/lispflowmapping/implementation/LfmMappingDatabaseRpc.java @@ -13,21 +13,31 @@ import org.opendaylight.controller.md.sal.binding.api.DataBroker; import org.opendaylight.lispflowmapping.implementation.mdsal.DataStoreBackEnd; import org.opendaylight.lispflowmapping.implementation.util.RPCInputConvertorUtil; import org.opendaylight.lispflowmapping.lisp.util.MapServerMapResolverUtil; +import org.opendaylight.lispflowmapping.lisp.util.MaskUtil; import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev150820.MapReply; import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev150820.MapRequest; import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.mappingservice.rev150820.AddKeyInput; +import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.mappingservice.rev150820.AddKeyInputBuilder; import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.mappingservice.rev150820.AddMappingInput; +import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.mappingservice.rev150820.AddMappingInputBuilder; import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.mappingservice.rev150820.GetKeyInput; +import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.mappingservice.rev150820.GetKeyInputBuilder; import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.mappingservice.rev150820.GetKeyOutput; import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.mappingservice.rev150820.GetKeyOutputBuilder; import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.mappingservice.rev150820.GetMappingInput; +import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.mappingservice.rev150820.GetMappingInputBuilder; import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.mappingservice.rev150820.GetMappingOutput; import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.mappingservice.rev150820.GetMappingOutputBuilder; import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.mappingservice.rev150820.MappingserviceService; import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.mappingservice.rev150820.RemoveKeyInput; +import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.mappingservice.rev150820.RemoveKeyInputBuilder; import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.mappingservice.rev150820.RemoveMappingInput; +import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.mappingservice.rev150820.RemoveMappingInputBuilder; import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.mappingservice.rev150820.UpdateKeyInput; +import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.mappingservice.rev150820.UpdateKeyInputBuilder; import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.mappingservice.rev150820.UpdateMappingInput; +import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.mappingservice.rev150820.UpdateMappingInputBuilder; +import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.mappingservice.rev150820.update.key.input.EidBuilder; import org.opendaylight.yangtools.yang.common.RpcError; import org.opendaylight.yangtools.yang.common.RpcResult; import org.opendaylight.yangtools.yang.common.RpcResultBuilder; @@ -67,8 +77,11 @@ public class LfmMappingDatabaseRpc implements MappingserviceService { RpcResultBuilder rpcResultBuilder; - String key = lispMappingService.getAuthenticationKey(input.getLispAddressContainer(), - input.getMaskLength()); + // XXX: to remove once RPC API has been updated to remove explicit mask + input = new AddKeyInputBuilder(input).setLispAddressContainer( + MaskUtil.setMask(input.getLispAddressContainer(), input.getMaskLength())).build(); + + String key = lispMappingService.getAuthenticationKey(input.getLispAddressContainer()); if (key != null) { String message = "Key already exists! Please use update-key if you want to change it."; @@ -88,6 +101,10 @@ public class LfmMappingDatabaseRpc implements MappingserviceService { Preconditions.checkNotNull(input, "add-mapping RPC input must be not null!"); LOG.trace("RPC received to add the following mapping: " + input.toString()); + // XXX: to remove once RPC API has been updated to remove explicit mask + input = new AddMappingInputBuilder(input).setLispAddressContainer( + MaskUtil.setMask(input.getLispAddressContainer(), input.getMaskLength())).build(); + dsbe.addMapping(RPCInputConvertorUtil.toMapping(input)); RpcResultBuilder rpcResultBuilder; @@ -102,9 +119,13 @@ public class LfmMappingDatabaseRpc implements MappingserviceService { Preconditions.checkNotNull(input, "get-key RPC input must be not null!"); LOG.trace("RPC received to get the following key: " + input.toString()); + // XXX: to remove once RPC API has been updated to remove explicit mask + input = new GetKeyInputBuilder(input).setLispAddressContainer( + MaskUtil.setMask(input.getLispAddressContainer(), input.getMaskLength())).build(); + RpcResultBuilder rpcResultBuilder; - String key = lispMappingService.getAuthenticationKey(input.getLispAddressContainer(), input.getMaskLength()); + String key = lispMappingService.getAuthenticationKey(input.getLispAddressContainer()); if (key == null) { String message = "Key was not found in the mapping database"; @@ -122,6 +143,10 @@ public class LfmMappingDatabaseRpc implements MappingserviceService { Preconditions.checkNotNull(input, "get-mapping RPC input must be not null!"); LOG.trace("RPC received to get the following mapping: " + input.toString()); + // XXX: to remove once RPC API has been updated to remove explicit mask + input = new GetMappingInputBuilder(input).setLispAddressContainer( + MaskUtil.setMask(input.getLispAddressContainer(), input.getMaskLength())).build(); + RpcResultBuilder rpcResultBuilder; MapRequest request = MapServerMapResolverUtil.getMapRequest(input.getLispAddressContainer(), @@ -145,6 +170,10 @@ public class LfmMappingDatabaseRpc implements MappingserviceService { Preconditions.checkNotNull(input, "remove-key RPC input must be not null!"); LOG.trace("RPC received to remove the following key: " + input.toString()); + // XXX: to remove once RPC API has been updated to remove explicit mask + input = new RemoveKeyInputBuilder(input).setLispAddressContainer( + MaskUtil.setMask(input.getLispAddressContainer(), input.getMaskLength())).build(); + RpcResultBuilder rpcResultBuilder; dsbe.removeAuthenticationKey(RPCInputConvertorUtil.toAuthenticationKey(input)); @@ -159,6 +188,10 @@ public class LfmMappingDatabaseRpc implements MappingserviceService { Preconditions.checkNotNull(input, "remove-mapping RPC input must be not null!"); LOG.trace("RPC received to remove the following mapping: " + input.toString()); + // XXX: to remove once RPC API has been updated to remove explicit mask + input = new RemoveMappingInputBuilder(input).setLispAddressContainer( + MaskUtil.setMask(input.getLispAddressContainer(), input.getMaskLength())).build(); + RpcResultBuilder rpcResultBuilder; dsbe.removeMapping(RPCInputConvertorUtil.toMapping(input)); @@ -173,10 +206,15 @@ public class LfmMappingDatabaseRpc implements MappingserviceService { Preconditions.checkNotNull(input, "update-key RPC input must be not null!"); LOG.trace("RPC received to update the following key: " + input.toString()); + // XXX: to remove once RPC API has been updated to remove explicit mask + input = new UpdateKeyInputBuilder(input).setEid( + new EidBuilder(input.getEid()).setLispAddressContainer( + MaskUtil.setMask(input.getEid().getLispAddressContainer(), input.getEid() + .getMaskLength())).build()).build(); + RpcResultBuilder rpcResultBuilder; - String key = lispMappingService.getAuthenticationKey(input.getEid().getLispAddressContainer(), - input.getEid().getMaskLength()); + String key = lispMappingService.getAuthenticationKey(input.getEid().getLispAddressContainer()); if (key == null) { String message = "Key doesn't exist! Please use add-key if you want to create a new authentication key."; @@ -196,6 +234,10 @@ public class LfmMappingDatabaseRpc implements MappingserviceService { LOG.trace("RPC received to update the following mapping: " + input.toString()); Preconditions.checkNotNull(input, "update-mapping RPC input must be not null!"); + // XXX: to remove once RPC API has been updated to remove explicit mask + input = new UpdateMappingInputBuilder(input).setLispAddressContainer( + MaskUtil.setMask(input.getLispAddressContainer(), input.getMaskLength())).build(); + RpcResultBuilder rpcResultBuilder; dsbe.updateMapping(RPCInputConvertorUtil.toMapping(input)); diff --git a/mappingservice/implementation/src/main/java/org/opendaylight/lispflowmapping/implementation/LispMappingService.java b/mappingservice/implementation/src/main/java/org/opendaylight/lispflowmapping/implementation/LispMappingService.java index 44fbae31a..cd4bfebb3 100644 --- a/mappingservice/implementation/src/main/java/org/opendaylight/lispflowmapping/implementation/LispMappingService.java +++ b/mappingservice/implementation/src/main/java/org/opendaylight/lispflowmapping/implementation/LispMappingService.java @@ -20,19 +20,16 @@ import org.opendaylight.controller.sal.binding.api.NotificationListener; 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.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.util.DAOSubKeys; import org.opendaylight.lispflowmapping.implementation.util.LispNotificationHelper; 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.dao.SubKeys; import org.opendaylight.lispflowmapping.interfaces.lisp.IFlowMapping; import org.opendaylight.lispflowmapping.interfaces.lisp.IFlowMappingShell; import org.opendaylight.lispflowmapping.interfaces.lisp.IMapNotifyHandler; @@ -64,7 +61,6 @@ import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.mappingservice.rev15082 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.mappingservice.rev150820.db.instance.AuthenticationKey; import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.mappingservice.rev150820.db.instance.Mapping; 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; import org.opendaylight.yangtools.yang.binding.Notification; import org.slf4j.Logger; @@ -135,18 +131,6 @@ public class LispMappingService implements IFlowMapping, IFlowMappingShell, Bind LOG.info("LISP (RFC6830) Mapping Service init finished"); } - class LispIpv4AddressInMemoryConverter implements ILispTypeConverter { - } - - class LispIpv6AddressInMemoryConverter implements ILispTypeConverter { - } - - class MappingServiceKeyConvertor implements ILispTypeConverter { - } - - class MappingServiceNoMaskKeyConvertor implements ILispTypeConverter { - } - public static LispMappingService getLispMappingService() { return lfmService; } @@ -192,7 +176,7 @@ public class LispMappingService implements IFlowMapping, IFlowMappingShell, Bind } for (AuthenticationKey authKey : authKeys) { - addAuthenticationKey(authKey.getLispAddressContainer(), authKey.getMaskLength(), authKey.getAuthkey()); + addAuthenticationKey(authKey.getLispAddressContainer(), authKey.getAuthkey()); } } @@ -214,7 +198,7 @@ public class LispMappingService implements IFlowMapping, IFlowMappingShell, Bind if (!lastKey.equals(key)) { sb.append(key + "\t"); } - if (!(valueKey.equals(DAOSubKeys.LCAF_SRCDST_SUBKEY.toString()))) { + if (!(valueKey.equals(SubKeys.LCAF_SRCDST))) { sb.append(valueKey + "=" + value + "\t"); } lastKey = key; @@ -228,7 +212,7 @@ public class LispMappingService implements IFlowMapping, IFlowMappingShell, Bind if (!lastKey.equals(key)) { sb.append("\n" + key + "\t"); } - if (valueKey.equals(DAOSubKeys.LCAF_SRCDST_SUBKEY.toString())) { + if (valueKey.equals(SubKeys.LCAF_SRCDST)) { sb.append(valueKey + "= { "); ((ILispDAO)value).getAll(innerVisitor); sb.append("}\t"); @@ -244,8 +228,8 @@ public class LispMappingService implements IFlowMapping, IFlowMappingShell, Bind public void addDefaultKeyIPv4() { LispAddressContainer address = LispAFIConvertor.toContainer( - new Ipv4AddressBuilder().setIpv4Address(new Ipv4Address("0.0.0.0")).build()); - addAuthenticationKey(address, 0, "password"); + new Ipv4AddressBuilder().setIpv4Address(new Ipv4Address("0.0.0.0")).setMask((short)0).build()); + addAuthenticationKey(address, "password"); } public MapReply handleMapRequest(MapRequest request) { @@ -254,14 +238,12 @@ public class LispMappingService implements IFlowMapping, IFlowMappingShell, Bind public MapReply handleMapRequest(MapRequest request, boolean smr) { LOG.debug("DAO: Retrieving mapping for {}", - LispAddressStringifier.getString(request.getEidRecord().get(0).getLispAddressContainer(), - request.getEidRecord().get(0).getMask())); + LispAddressStringifier.getString(request.getEidRecord().get(0).getLispAddressContainer())); tlsMapReply.set(null); tlsMapRequest.set(null); mapResolver.handleMapRequest(request, smr, this); - // After this invocation we assume that the thread local is filled with - // the reply + // After this invocation we assume that the thread local is filled with the reply if (tlsMapRequest.get() != null) { SendMapRequestInputBuilder smrib = new SendMapRequestInputBuilder(); new MapRequestBuilder(tlsMapRequest.get().getLeft()); @@ -281,35 +263,33 @@ public class LispMappingService implements IFlowMapping, IFlowMappingShell, Bind public MapNotify handleMapRegister(MapRegister mapRegister, boolean smr) { LOG.debug("DAO: Adding mapping for {}", - LispAddressStringifier.getString(mapRegister.getEidToLocatorRecord().get(0).getLispAddressContainer(), - mapRegister.getEidToLocatorRecord().get(0).getMaskLength())); + LispAddressStringifier.getString(mapRegister.getEidToLocatorRecord().get(0).getLispAddressContainer())); tlsMapNotify.set(null); mapServer.handleMapRegister(mapRegister, smr, this); - // After this invocation we assume that the thread local is filled with - // the reply + // After this invocation we assume that the thread local is filled with the reply return tlsMapNotify.get(); } - public String getAuthenticationKey(LispAddressContainer address, int maskLen) { - LOG.debug("DAO: Retrieving authentication key for {}", LispAddressStringifier.getString(address, maskLen)); - return mapServer.getAuthenticationKey(address, maskLen); + public String getAuthenticationKey(LispAddressContainer address) { + LOG.debug("DAO: Retrieving authentication key for {}", LispAddressStringifier.getString(address)); + return mapServer.getAuthenticationKey(address); } - public void removeAuthenticationKey(LispAddressContainer address, int maskLen) { - LOG.debug("DAO: Removing authentication key for {}", LispAddressStringifier.getString(address, maskLen)); - mapServer.removeAuthenticationKey(address, maskLen); + public void removeAuthenticationKey(LispAddressContainer address) { + LOG.debug("DAO: Removing authentication key for {}", LispAddressStringifier.getString(address)); + mapServer.removeAuthenticationKey(address); } - public void addAuthenticationKey(LispAddressContainer address, int maskLen, String key) { + public void addAuthenticationKey(LispAddressContainer address, String key) { LOG.debug("DAO: Adding authentication key '{}' for {}", key, - LispAddressStringifier.getString(address, maskLen)); - mapServer.addAuthenticationKey(address, maskLen, key); + LispAddressStringifier.getString(address)); + mapServer.addAuthenticationKey(address, key); } - public void removeMapping(LispAddressContainer address, int maskLen) { - LOG.debug("DAO: Removing mapping for {}", LispAddressStringifier.getString(address, maskLen)); - mapServer.removeMapping(address, maskLen, smr, this); + public void removeMapping(LispAddressContainer address) { + LOG.debug("DAO: Removing mapping for {}", LispAddressStringifier.getString(address)); + mapServer.removeMapping(address, smr, this); } public boolean shouldIterateMask() { @@ -418,8 +398,7 @@ public class LispMappingService implements IFlowMapping, IFlowMappingShell, Bind LOG.debug("Sending SMR to {} with Source-EID {} and EID Record {}", LispAddressStringifier.getString(subscriber), LispAddressStringifier.getString(smr.getSourceEid().getLispAddressContainer()), - LispAddressStringifier.getString(smr.getEidRecord().get(0).getLispAddressContainer(), - smr.getEidRecord().get(0).getMask())); + LispAddressStringifier.getString(smr.getEidRecord().get(0).getLispAddressContainer())); SendMapRequestInputBuilder smrib = new SendMapRequestInputBuilder(); smrib.setMapRequest(new MapRequestBuilder(smr).build()); smrib.setTransportAddress(LispNotificationHelper.getTransportAddressFromContainer(subscriber)); diff --git a/mappingservice/implementation/src/main/java/org/opendaylight/lispflowmapping/implementation/dao/MappingKey.java b/mappingservice/implementation/src/main/java/org/opendaylight/lispflowmapping/implementation/dao/MappingKey.java deleted file mode 100644 index bc303f119..000000000 --- a/mappingservice/implementation/src/main/java/org/opendaylight/lispflowmapping/implementation/dao/MappingKey.java +++ /dev/null @@ -1,67 +0,0 @@ -/* - * 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.implementation.dao; - -import org.opendaylight.lispflowmapping.interfaces.dao.IMappingKey; -import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev150820.lispaddress.LispAddressContainer; - -public class MappingKey implements IMappingKey { - - private LispAddressContainer EID; - private int mask; - - public MappingKey(LispAddressContainer lispAddressContainer, int mask) { - this.EID = lispAddressContainer; - this.mask = mask; - } - - public LispAddressContainer getEID() { - return EID; - } - - public int getMask() { - return mask & 0xFF; - } - - @Override - public int hashCode() { - final int prime = 31; - int result = 1; - result = prime * result + ((EID == null) ? 0 : EID.hashCode()); - result = prime * result + mask; - return result; - } - - @Override - public boolean equals(Object obj) { - if (this == obj) - return true; - if (obj == null) - return false; - if (getClass() != obj.getClass()) - return false; - MappingKey other = (MappingKey) obj; - if (EID == null) { - if (other.EID != null) - return false; - } else if (!EID.equals(other.EID)) - return false; - if (mask != other.mask) - return false; - return true; - } - - @Override - public String toString() { - if (mask > 0) { - return EID.toString() + "/" + mask; - } - return EID.toString(); - } - -} diff --git a/mappingservice/implementation/src/main/java/org/opendaylight/lispflowmapping/implementation/dao/MappingKeyUtil.java b/mappingservice/implementation/src/main/java/org/opendaylight/lispflowmapping/implementation/dao/MappingKeyUtil.java deleted file mode 100644 index aa8917161..000000000 --- a/mappingservice/implementation/src/main/java/org/opendaylight/lispflowmapping/implementation/dao/MappingKeyUtil.java +++ /dev/null @@ -1,44 +0,0 @@ -/* - * 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.implementation.dao; - -import org.opendaylight.lispflowmapping.implementation.util.MaskUtil; -import org.opendaylight.lispflowmapping.interfaces.dao.IMappingKey; -import org.opendaylight.lispflowmapping.lisp.util.LispAFIConvertor; -import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev150820.LispAFIAddress; -import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev150820.lispaddress.LispAddressContainer; - -public class MappingKeyUtil { - - 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 MappingKey(normalizedAddress, mask); - } else { - return new MappingNoMaskKey(lispAddressContainer); - } - } - - public static IMappingKey generateMappingKey(LispAFIAddress address, int mask) { - if (MaskUtil.isMaskable(address)) { - LispAddressContainer normalizedAddress = LispAFIConvertor.toContainer(MaskUtil.normalize(address, mask)); - return new MappingKey(normalizedAddress, mask); - } else { - return new MappingNoMaskKey(LispAFIConvertor.toContainer(address)); - } - } - - public static IMappingKey generateMappingKey(LispAddressContainer lispAddressContainer) { - LispAFIAddress address = LispAFIConvertor.toAFI(lispAddressContainer); - if (MaskUtil.isMaskable(address)) { - return generateMappingKey(lispAddressContainer, MaskUtil.getMaxMask(address)); - } else - return generateMappingKey(lispAddressContainer, 0); - } -} diff --git a/mappingservice/implementation/src/main/java/org/opendaylight/lispflowmapping/implementation/dao/MappingNoMaskKey.java b/mappingservice/implementation/src/main/java/org/opendaylight/lispflowmapping/implementation/dao/MappingNoMaskKey.java deleted file mode 100644 index 2ed78ff07..000000000 --- a/mappingservice/implementation/src/main/java/org/opendaylight/lispflowmapping/implementation/dao/MappingNoMaskKey.java +++ /dev/null @@ -1,67 +0,0 @@ -/* - * 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.implementation.dao; - -import org.opendaylight.lispflowmapping.implementation.util.MaskUtil; -import org.opendaylight.lispflowmapping.interfaces.dao.IMappingKey; -import org.opendaylight.lispflowmapping.lisp.util.LispAFIConvertor; -import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev150820.LispAFIAddress; -import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev150820.lispaddress.LispAddressContainer; - -public class MappingNoMaskKey implements IMappingKey { - - private LispAddressContainer EID; - - public MappingNoMaskKey(LispAddressContainer lispAddressContainer) { - this.EID = lispAddressContainer; - } - - public LispAddressContainer getEID() { - return EID; - } - - public int getMask() { - LispAFIAddress eidAFIAddress = LispAFIConvertor.toAFI(EID); - if (MaskUtil.isMaskable(eidAFIAddress)) { - return MaskUtil.getMaxMask(eidAFIAddress); - } else { - return 0; - } - } - - @Override - public int hashCode() { - final int prime = 31; - int result = 1; - result = prime * result + ((EID == null) ? 0 : EID.hashCode()); - return result; - } - - @Override - public boolean equals(Object obj) { - if (this == obj) - return true; - if (obj == null) - return false; - if (getClass() != obj.getClass()) - return false; - MappingNoMaskKey other = (MappingNoMaskKey) obj; - if (EID == null) { - if (other.EID != null) - return false; - } else if (!EID.equals(other.EID)) - return false; - return true; - } - - @Override - public String toString() { - return EID.toString(); - } - -} diff --git a/mappingservice/implementation/src/main/java/org/opendaylight/lispflowmapping/implementation/lisp/MapResolver.java b/mappingservice/implementation/src/main/java/org/opendaylight/lispflowmapping/implementation/lisp/MapResolver.java index 212c56a31..298e20c2c 100644 --- a/mappingservice/implementation/src/main/java/org/opendaylight/lispflowmapping/implementation/lisp/MapResolver.java +++ b/mappingservice/implementation/src/main/java/org/opendaylight/lispflowmapping/implementation/lisp/MapResolver.java @@ -10,22 +10,18 @@ package org.opendaylight.lispflowmapping.implementation.lisp; import java.util.ArrayList; import java.util.List; -import java.util.Map.Entry; import java.util.Set; import org.apache.commons.lang3.exception.ExceptionUtils; import org.opendaylight.lispflowmapping.implementation.config.ConfigIni; -import org.opendaylight.lispflowmapping.implementation.util.DAOMappingUtil; +import org.opendaylight.lispflowmapping.implementation.mapcache.TopologyMapCache; import org.opendaylight.lispflowmapping.interfaces.dao.ILispDAO; -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.lisp.proto.rev150820.EidToLocatorRecord.Action; import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev150820.LcafTrafficEngineeringAddress; -import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev150820.LispAFIAddress; import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev150820.MapRequest; import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev150820.eidrecords.EidRecord; import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev150820.eidtolocatorrecords.EidToLocatorRecord; @@ -33,7 +29,6 @@ import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev150820.ei import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev150820.lcaftrafficengineeringaddress.Hops; import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev150820.lispaddress.LispAddressContainer; import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev150820.lispaddress.lispaddresscontainer.address.LcafTrafficEngineering; -import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev150820.lispaddress.lispaddresscontainer.address.No; import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev150820.locatorrecords.LocatorRecord; import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev150820.locatorrecords.LocatorRecordBuilder; import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev150820.mapreplymessage.MapReplyBuilder; @@ -65,10 +60,8 @@ public class MapResolver extends AbstractLispComponent implements IMapResolverAs Preconditions.checkNotNull(dao); LispAddressContainer srcEid = null; - LispAFIAddress srcEidAfi = null; if (request.getSourceEid() != null) { srcEid = request.getSourceEid().getLispAddressContainer(); - srcEidAfi = LispAFIConvertor.toAFI(srcEid); } MapReplyBuilder builder = new MapReplyBuilder(); builder.setEchoNonceEnabled(false); @@ -76,27 +69,17 @@ public class MapResolver extends AbstractLispComponent implements IMapResolverAs builder.setSecurityEnabled(false); builder.setNonce(request.getNonce()); builder.setEidToLocatorRecord(new ArrayList()); - for (EidRecord eid : request.getEidRecord()) { - EidToLocatorRecordBuilder recordBuilder = new EidToLocatorRecordBuilder(); - Entry> mapping = - DAOMappingUtil.getMapping(srcEidAfi, eid, dao); - recordBuilder.setRecordTtl(0); - recordBuilder.setAction(Action.NoAction); - recordBuilder.setAuthoritative(false); - recordBuilder.setMapVersion((short) 0); - recordBuilder.setMaskLength((short) mapping.getKey().getMask()); - recordBuilder.setLispAddressContainer(mapping.getKey().getEID()); - recordBuilder.setLocatorRecord(new ArrayList()); - List locators = mapping.getValue(); - if (locators != null && locators.size() > 0) { + for (EidRecord eidRecord : request.getEidRecord()) { + EidToLocatorRecord mapping = TopologyMapCache.getMapping(srcEid, eidRecord.getLispAddressContainer(), dao); + EidToLocatorRecordBuilder recordBuilder; + if (mapping != null) { + recordBuilder = new EidToLocatorRecordBuilder(mapping); List itrRlocs = request.getItrRloc(); - addLocatorGroups(recordBuilder, locators, itrRlocs); - if (srcEid != null && !(srcEid.getAddress() instanceof No) && itrRlocs != null - && itrRlocs.size() > 0) { + if (itrRlocs != null && itrRlocs.size() != 0) { + updateLocators(recordBuilder, itrRlocs); LispAddressContainer itrRloc = itrRlocs.get(0).getLispAddressContainer(); SubscriberRLOC subscriberRloc = new SubscriberRLOC(itrRloc, srcEid); - Set subscribers = DAOMappingUtil.getSubscribers(mapping.getKey().getEID(), - mapping.getKey().getMask(), dao); + Set subscribers = TopologyMapCache.getSubscribers(mapping.getLispAddressContainer(), dao); if (subscribers == null) { subscribers = Sets.newConcurrentHashSet(); } else if (subscribers.contains(subscriberRloc)) { @@ -107,13 +90,17 @@ public class MapResolver extends AbstractLispComponent implements IMapResolverAs if (smr) { LOG.trace("Adding new subscriber: " + subscriberRloc.toString()); subscribers.add(subscriberRloc); - DAOMappingUtil.addSubscribers(mapping.getKey().getEID(), mapping.getKey().getMask(), - subscribers, dao); + TopologyMapCache.addSubscribers(mapping.getLispAddressContainer(), subscribers, dao); } } } else { + recordBuilder = new EidToLocatorRecordBuilder(); + recordBuilder.setAuthoritative(false); + recordBuilder.setMapVersion((short) 0); + recordBuilder.setMaskLength(eidRecord.getMask()); + recordBuilder.setLispAddressContainer(eidRecord.getLispAddressContainer()); recordBuilder.setAction(Action.NativelyForward); - if (shouldAuthenticate() && DAOMappingUtil.getPassword(eid.getLispAddressContainer(), eid.getMask(), + if (shouldAuthenticate() && TopologyMapCache.getAuthenticationKey(eidRecord.getLispAddressContainer(), dao, shouldIterateMask()) != null) { recordBuilder.setRecordTtl(TTL_RLOC_TIMED_OUT); } else { @@ -126,24 +113,12 @@ public class MapResolver extends AbstractLispComponent implements IMapResolverAs callback.handleMapReply(builder.build()); } - private void addLocatorGroups(EidToLocatorRecordBuilder recordBuilder, List rlocs, - List itrRlocs) { - for (RLOCGroup rloc : rlocs) { - addLocators(recordBuilder, rloc, itrRlocs); - recordBuilder.setRecordTtl(rloc.getTtl()); - } - } - - private void addLocators(EidToLocatorRecordBuilder recordBuilder, RLOCGroup locatorObject, - List itrRlocs) { - Preconditions.checkNotNull(locatorObject); - - recordBuilder.setAction(locatorObject.getAction()); - recordBuilder.setAuthoritative(locatorObject.isAuthoritative()); - recordBuilder.setRecordTtl(locatorObject.getTtl()); - + // Process locators according to configured policy + private void updateLocators(EidToLocatorRecordBuilder recordBuilder, List itrRlocs) { + List locatorRecords = recordBuilder.getLocatorRecord(); + recordBuilder.setLocatorRecord(new ArrayList()); try { - for (LocatorRecord record : locatorObject.getRecords()) { + for (LocatorRecord record : locatorRecords) { LispAddressContainer container = record.getLispAddressContainer(); // For non-ELP RLOCs, or when ELP policy is default, or itrRlocs is null, just add the locator and be diff --git a/mappingservice/implementation/src/main/java/org/opendaylight/lispflowmapping/implementation/lisp/MapServer.java b/mappingservice/implementation/src/main/java/org/opendaylight/lispflowmapping/implementation/lisp/MapServer.java index bbebb8e04..216843b2d 100644 --- a/mappingservice/implementation/src/main/java/org/opendaylight/lispflowmapping/implementation/lisp/MapServer.java +++ b/mappingservice/implementation/src/main/java/org/opendaylight/lispflowmapping/implementation/lisp/MapServer.java @@ -19,15 +19,16 @@ 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.util.DAOMappingUtil; -import org.opendaylight.lispflowmapping.implementation.util.MaskUtil; +import org.opendaylight.lispflowmapping.implementation.mapcache.TopologyMapCache; import org.opendaylight.lispflowmapping.interfaces.dao.ILispDAO; import org.opendaylight.lispflowmapping.interfaces.dao.SubscriberRLOC; import org.opendaylight.lispflowmapping.interfaces.lisp.IMapNotifyHandler; import org.opendaylight.lispflowmapping.interfaces.lisp.IMapServerAsync; +import org.opendaylight.lispflowmapping.lisp.util.LcafSourceDestHelper; import org.opendaylight.lispflowmapping.lisp.util.LispAFIConvertor; import org.opendaylight.lispflowmapping.lisp.util.MapNotifyBuilderHelper; import org.opendaylight.lispflowmapping.lisp.util.MapRequestUtil; +import org.opendaylight.lispflowmapping.lisp.util.MaskUtil; import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev150820.MapRegister; import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev150820.eidrecords.EidRecord; import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev150820.eidrecords.EidRecordBuilder; @@ -91,61 +92,60 @@ public class MapServer extends AbstractLispComponent implements IMapServerAsync public void handleMapRegister(MapRegister mapRegister, boolean smr, IMapNotifyHandler callback) { if (dao == null) { LOG.warn("handleMapRegister called while dao is uninitialized"); - } else { - boolean failed = false; - String password = null; - for (EidToLocatorRecord eidRecord : mapRegister.getEidToLocatorRecord()) { - if (shouldAuthenticate()) { - password = DAOMappingUtil.getPassword(eidRecord.getLispAddressContainer(), - eidRecord.getMaskLength(), dao, shouldIterateMask()); - if (!LispAuthenticationUtil.validate(mapRegister, password)) { - LOG.warn("Authentication failed"); - failed = true; - break; - } - } - boolean mappingChanged = DAOMappingUtil.saveRlocs(eidRecord, smr, dao, shouldIterateMask(), - shouldOverwrite()); - if (smr && mappingChanged) { - Set subscribers = DAOMappingUtil.getSubscribers( - eidRecord.getLispAddressContainer(), eidRecord.getMaskLength(), dao); - sendSmrs(eidRecord, subscribers, callback); + return; + } + boolean failed = false; + String password = null; + for (EidToLocatorRecord eidRecord : mapRegister.getEidToLocatorRecord()) { + if (shouldAuthenticate()) { + password = TopologyMapCache.getAuthenticationKey(eidRecord.getLispAddressContainer(), dao, shouldIterateMask()); + if (!LispAuthenticationUtil.validate(mapRegister, password)) { + LOG.warn("Authentication failed"); + failed = true; + break; } } - if (!failed) { - MapNotifyBuilder builder = new MapNotifyBuilder(); - if (BooleanUtils.isTrue(mapRegister.isWantMapNotify())) { - LOG.trace("MapRegister wants MapNotify"); - MapNotifyBuilderHelper.setFromMapRegister(builder, mapRegister); - if (shouldAuthenticate()) { - builder.setAuthenticationData(LispAuthenticationUtil.createAuthenticationData(builder.build(), - password)); - } - callback.handleMapNotify(builder.build()); + boolean mappingChanged = TopologyMapCache.addMapping(eidRecord, smr, dao, shouldIterateMask(), + shouldOverwrite()); + if (smr && mappingChanged) { + Set subscribers = TopologyMapCache.getSubscribers( + eidRecord.getLispAddressContainer(), dao); + sendSmrs(eidRecord, subscribers, callback); + } + } + if (!failed) { + MapNotifyBuilder builder = new MapNotifyBuilder(); + if (BooleanUtils.isTrue(mapRegister.isWantMapNotify())) { + LOG.trace("MapRegister wants MapNotify"); + MapNotifyBuilderHelper.setFromMapRegister(builder, mapRegister); + if (shouldAuthenticate()) { + builder.setAuthenticationData(LispAuthenticationUtil.createAuthenticationData(builder.build(), + password)); } + callback.handleMapNotify(builder.build()); } } } - public String getAuthenticationKey(LispAddressContainer address, int maskLen) { - return DAOMappingUtil.getPassword(address, maskLen, dao, shouldIterateMask()); + public String getAuthenticationKey(LispAddressContainer address) { + return TopologyMapCache.getAuthenticationKey(address, dao, shouldIterateMask()); } - public void removeAuthenticationKey(LispAddressContainer address, int maskLen) { - DAOMappingUtil.removeAuthenticationKey(address, maskLen, dao); + public void removeAuthenticationKey(LispAddressContainer address) { + TopologyMapCache.removeAuthenticationKey(address, dao); } - public void removeMapping(LispAddressContainer address, int maskLen, boolean smr, IMapNotifyHandler callback) { + public void removeMapping(LispAddressContainer address, boolean smr, IMapNotifyHandler callback) { if (smr) { // mapping is removed before first SMR is sent to avoid inconsistent replies - DAOMappingUtil.removeMapping(address, maskLen, dao, shouldOverwrite()); - Set subscribers = DAOMappingUtil.getSubscribers(address, maskLen, dao); + TopologyMapCache.removeMapping(address, dao, shouldOverwrite()); + Set subscribers = TopologyMapCache.getSubscribers(address, dao); sendSmrs(new EidToLocatorRecordBuilder().setLispAddressContainer(address). - setMaskLength((short) maskLen).build(), subscribers, callback); - DAOMappingUtil.removeSubscribers(address, maskLen, dao, shouldOverwrite()); + setMaskLength(MaskUtil.getMaskForAddress(address)).build(), subscribers, callback); + TopologyMapCache.removeSubscribers(address, dao, shouldOverwrite()); } else { - DAOMappingUtil.removeMapping(address, maskLen, dao, shouldOverwrite()); - DAOMappingUtil.removeSubscribers(address, maskLen, dao, shouldOverwrite()); + TopologyMapCache.removeMapping(address, dao, shouldOverwrite()); + TopologyMapCache.removeSubscribers(address, dao, shouldOverwrite()); } } @@ -155,9 +155,9 @@ public class MapServer extends AbstractLispComponent implements IMapServerAsync // For SrcDst LCAF also send SMRs to Dst prefix if (eid.getAddress() instanceof LcafSourceDest) { - LispAddressContainer dstAddr = LispAFIConvertor.toContainer(DAOMappingUtil.getDstForLcafSrcDst(eid)); - short dstMask = DAOMappingUtil.getDstMaskForLcafSrcDst(eid); - subscribers = DAOMappingUtil.getSubscribers(dstAddr, dstMask, dao); + LispAddressContainer dstAddr = LispAFIConvertor.toContainer(LcafSourceDestHelper.getDstAfi(eid)); + short dstMask = LcafSourceDestHelper.getDstMask(eid); + subscribers = TopologyMapCache.getSubscribers(dstAddr, dao); EidToLocatorRecord newRecord = new EidToLocatorRecordBuilder().setAction(record.getAction()). setAuthoritative(record.isAuthoritative()).setLocatorRecord(record.getLocatorRecord()). setMapVersion(record.getMapVersion()).setRecordTtl(record.getRecordTtl()). @@ -191,7 +191,7 @@ public class MapServer extends AbstractLispComponent implements IMapServerAsync } } } - DAOMappingUtil.addSubscribers(record.getLispAddressContainer(), record.getMaskLength(), subscribers, dao); + TopologyMapCache.addSubscribers(record.getLispAddressContainer(), subscribers, dao); } public boolean shouldOverwrite() { @@ -203,8 +203,8 @@ public class MapServer extends AbstractLispComponent implements IMapServerAsync } @Override - public void addAuthenticationKey(LispAddressContainer address, int maskLen, String key) { - DAOMappingUtil.addAuthenticationKey(address, maskLen, key, dao); + public void addAuthenticationKey(LispAddressContainer address, String key) { + TopologyMapCache.addAuthenticationKey(address, key, dao); } } diff --git a/mappingservice/implementation/src/main/java/org/opendaylight/lispflowmapping/implementation/mapcache/TopologyMapCache.java b/mappingservice/implementation/src/main/java/org/opendaylight/lispflowmapping/implementation/mapcache/TopologyMapCache.java new file mode 100644 index 000000000..2d5078d31 --- /dev/null +++ b/mappingservice/implementation/src/main/java/org/opendaylight/lispflowmapping/implementation/mapcache/TopologyMapCache.java @@ -0,0 +1,282 @@ +/* + * 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.implementation.mapcache; + +import java.util.Date; +import java.util.Map; +import java.util.Set; + +import org.opendaylight.lispflowmapping.interfaces.dao.ILispDAO; +import org.opendaylight.lispflowmapping.interfaces.dao.MappingEntry; +import org.opendaylight.lispflowmapping.interfaces.dao.SubKeys; +import org.opendaylight.lispflowmapping.interfaces.dao.SubscriberRLOC; +import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev150820.eidtolocatorrecords.EidToLocatorRecord; +import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev150820.eidtolocatorrecords.EidToLocatorRecordBuilder; +import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev150820.lispaddress.LispAddressContainer; +import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev150820.lispaddress.lispaddresscontainer.address.LcafSourceDest; +import org.opendaylight.lispflowmapping.lisp.util.LcafSourceDestHelper; +import org.opendaylight.lispflowmapping.lisp.util.LispAFIConvertor; +import org.opendaylight.lispflowmapping.lisp.util.MaskUtil; +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; + +public class TopologyMapCache { + private static final Logger LOG = LoggerFactory.getLogger(TopologyMapCache.class); + + public static boolean addMapping(EidToLocatorRecord record, boolean checkForChanges, ILispDAO dao, + boolean shouldIterate, boolean shouldOverwrite) { + LispAddressContainer eid = MaskUtil.normalize(record.getLispAddressContainer()); + EidToLocatorRecord oldMapping = null; + if (eid.getAddress() instanceof LcafSourceDest) { + LispAddressContainer srcAddr = LcafSourceDestHelper.getSrc(eid); + LispAddressContainer dstAddr = LcafSourceDestHelper.getDst(eid); + + if (checkForChanges) { + oldMapping = getMappingExactSD(srcAddr, dstAddr, dao); + } + ILispDAO srcDstDao = getOrInstantiateSDInnerDao(eid, dao); + srcDstDao.put(LcafSourceDestHelper.getSrc(eid), + new MappingEntry<>(SubKeys.REGDATE, new Date(System.currentTimeMillis()))); + srcDstDao.put(LcafSourceDestHelper.getSrc(eid), new MappingEntry<>(SubKeys.RECORD, record)); + if (checkForChanges && oldMapping != null && eid.equals(oldMapping.getLispAddressContainer())) { + return true; + } + } else { + if (checkForChanges) { + oldMapping = getMappingExactSD(null, eid, dao); + } + dao.put(eid, new MappingEntry<>(SubKeys.REGDATE, new Date(System.currentTimeMillis()))); + dao.put(eid, new MappingEntry<>(SubKeys.RECORD, record)); + if (checkForChanges && oldMapping != null && eid.equals(oldMapping.getLispAddressContainer())) { + return true; + } + } + return false; + } + + // Method returns the DAO entry (hash) corresponding to either the longest prefix match of eid, if eid is maskable, + // or the exact match otherwise. eid must be a 'simple' address + private static Map getDaoEntryBest(LispAddressContainer eid, ILispDAO dao) { + if (MaskUtil.isMaskable(eid)) { + LispAddressContainer key; + short mask = MaskUtil.getMaskForAddress(eid); + while (mask > 0) { + key = MaskUtil.normalize(eid, mask); + mask--; + Map entry = dao.get(key); + if (entry != null) { + return entry; + } + } + return null; + } else { + Map entry = dao.get(eid); + if (entry != null) { + return dao.get(eid); + } else { + return null; + } + } + } + + private static EidToLocatorRecord getMappingExactSD(LispAddressContainer srcEid, LispAddressContainer dstEid, + ILispDAO dao) { + Map daoEntry = dao.get(dstEid); + if (daoEntry != null) { + // try SrcDst eid lookup + ILispDAO srcDstDao = (ILispDAO) daoEntry.get(SubKeys.LCAF_SRCDST); + if (srcEid != null && srcDstDao != null) { + EidToLocatorRecord mapping = (EidToLocatorRecord) srcDstDao.getSpecific(srcEid, SubKeys.RECORD); + return mapping; + } + // if lookup fails, return whatever is found for dst eid + return (EidToLocatorRecord) daoEntry.get(SubKeys.RECORD); + } + return null; + } + + // Returns the mapping corresponding to the longest prefix match for eid. eid must be a simple (maskable or not) address + private static EidToLocatorRecord getMappingLpmEid(LispAddressContainer eid, ILispDAO dao) { + Map daoEntry = getDaoEntryBest(eid, dao); + if (daoEntry != null) { + return (EidToLocatorRecord) daoEntry.get(SubKeys.RECORD); + } else { + return null; + } + } + + // Returns a mapping corresponding to either the longest prefix match for both dstEid and srcEid, + // if a SourceDest mapping exists, or to dstEid + private static EidToLocatorRecord getMappingLpmSD(LispAddressContainer srcEid, LispAddressContainer dstEid, ILispDAO dao) { + Map daoEntry = getDaoEntryBest(dstEid, dao); + if (daoEntry != null) { + + // try SrcDst eid lookup + ILispDAO srcDstDao = (ILispDAO) daoEntry.get(SubKeys.LCAF_SRCDST); + if (srcDstDao != null) { + EidToLocatorRecord mapping = getMappingLpmEid(srcEid, srcDstDao); + if (mapping!= null) { + return mapping; + } + } + + // if lookup fails, return whatever is found for dst eid + return (EidToLocatorRecord) daoEntry.get(SubKeys.RECORD); + } + return null; + } + + public static EidToLocatorRecord getMapping(LispAddressContainer srcEid, LispAddressContainer dstEid, + ILispDAO dao) { + // a map-request for an actual SrcDst LCAF, ignore src eid + if (dstEid.getAddress() instanceof LcafSourceDest) { + LispAddressContainer srcAddr = LcafSourceDestHelper.getSrc(dstEid); + LispAddressContainer dstAddr = LcafSourceDestHelper.getDst(dstEid); + return getMappingLpmSD(srcAddr, dstAddr, dao); + } + + // potential map-request for SrcDst LCAF from non SrcDst capable devices + EidToLocatorRecord mapping = getMappingLpmSD(srcEid, dstEid, dao); + + if (mapping == null) { + return null; + } + + // if indeed SrcDst LCAF change the mapping's eid to matched dstEid + if (mapping.getLispAddressContainer().getAddress() instanceof LcafSourceDest) { + EidToLocatorRecord newMapping = new EidToLocatorRecordBuilder(mapping).setLispAddressContainer( + LcafSourceDestHelper.getDst(mapping.getLispAddressContainer())).build(); + return newMapping; + } + + return mapping; + } + + public static void removeMapping(LispAddressContainer address, ILispDAO dao, boolean oerwrite) { + if (address.getAddress() instanceof LcafSourceDest) { + ILispDAO db = getSDInnerDao(address, dao); + if (db != null) { + db.removeSpecific(LcafSourceDestHelper.getSrc(address), + SubKeys.RECORD); + } + } else { + dao.removeSpecific(address, SubKeys.RECORD); + } + } + + public static void addAuthenticationKey(LispAddressContainer address, String key, ILispDAO dao) { + if (address.getAddress() instanceof LcafSourceDest) { + ILispDAO srcDstDao = getOrInstantiateSDInnerDao(address, dao); + srcDstDao.put(LcafSourceDestHelper.getSrc(address), new MappingEntry(SubKeys.PASSWORD, key)); + } else { + dao.put(address, new MappingEntry(SubKeys.PASSWORD, key)); + } + } + + private static String getAuthKeyLpm(LispAddressContainer prefix, ILispDAO db) { + short maskLength = MaskUtil.getMaskForAddress(prefix); + while (maskLength >= 0) { + LispAddressContainer key = MaskUtil.normalize(prefix, maskLength); + Object password = db.getSpecific(key, SubKeys.PASSWORD); + if (password != null && password instanceof String) { + return (String) password; + } + maskLength -= 1; + } + return null; + } + + public static String getAuthenticationKey(LispAddressContainer eid, ILispDAO dao, boolean iterate) { + if (MaskUtil.isMaskable(LispAFIConvertor.toAFI(eid)) && iterate) { + return getAuthKeyLpm(eid, dao); + } else if (eid.getAddress() instanceof LcafSourceDest && iterate) { + // NOTE: this is an exact match, not a longest prefix match + ILispDAO srcDstDao = getSDInnerDao(eid, dao); + if (srcDstDao != null) { + return getAuthKeyLpm(LcafSourceDestHelper.getSrc(eid), srcDstDao); + } + return null; + } else { + Object password = dao.getSpecific(eid, SubKeys.PASSWORD); + if (password != null && password instanceof String) { + return (String) password; + } else { + LOG.warn("Failed to find password!"); + return null; + } + } + } + + public static void removeAuthenticationKey(LispAddressContainer eid, ILispDAO dao) { + if (eid.getAddress() instanceof LcafSourceDest) { + ILispDAO srcDstDao = getSDInnerDao(eid, dao); + if (srcDstDao != null) { + srcDstDao.removeSpecific(eid, SubKeys.PASSWORD); + } + } else { + dao.removeSpecific(eid, SubKeys.PASSWORD); + } + } + + public static void addSubscribers(LispAddressContainer eid, Set subscribers, + ILispDAO dao) { + if (eid.getAddress() instanceof LcafSourceDest) { + ILispDAO srcDstDao = getOrInstantiateSDInnerDao(eid, dao); + srcDstDao.put(LcafSourceDestHelper.getSrc(eid), new MappingEntry>( + SubKeys.SUBSCRIBERS, subscribers)); + } else { + dao.put(eid, new MappingEntry>(SubKeys.SUBSCRIBERS, subscribers)); + } + } + + @SuppressWarnings("unchecked") + public static Set getSubscribers(LispAddressContainer eid, ILispDAO dao) { + Object subscribers; + if (eid.getAddress() instanceof LcafSourceDest) { + ILispDAO srcDstDao = getSDInnerDao(eid, dao); + subscribers = srcDstDao.getSpecific(LcafSourceDestHelper.getSrc(eid), SubKeys.SUBSCRIBERS); + } else { + subscribers = dao.getSpecific(eid, SubKeys.SUBSCRIBERS); + } + + if (subscribers != null && subscribers instanceof Set) { + return (Set) subscribers; + } + return null; + } + + public static void removeSubscribers(LispAddressContainer address, ILispDAO dao, boolean shouldOverwrite) { + if (address.getAddress() instanceof LcafSourceDest) { + ILispDAO db = getSDInnerDao(address, dao); + if (db != null) { + db.removeSpecific(LcafSourceDestHelper.getSrc(address), SubKeys.SUBSCRIBERS); + } + } else { + dao.removeSpecific(address, SubKeys.SUBSCRIBERS); + } + } + + // 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 getOrInstantiateSDInnerDao(LispAddressContainer address, ILispDAO dao) { + ILispDAO srcDstDao = (ILispDAO) dao.getSpecific(LcafSourceDestHelper.getDst(address), + SubKeys.LCAF_SRCDST); + if (srcDstDao == null) { + // inserts nested table for source + srcDstDao = dao.putNestedTable(LcafSourceDestHelper.getDst(address), SubKeys.LCAF_SRCDST); + } + return srcDstDao; + } + + // SrcDst LCAFs are stored in a 2-tier DAO with dst having priority over src. + // This method returns the DAO associated to dst or null if it doesn't exist. + public static ILispDAO getSDInnerDao(LispAddressContainer address, ILispDAO dao) { + return (ILispDAO) dao.getSpecific(LcafSourceDestHelper.getDst(address), SubKeys.LCAF_SRCDST); + } +} diff --git a/mappingservice/implementation/src/main/java/org/opendaylight/lispflowmapping/implementation/mdsal/AuthenticationKeyDataListener.java b/mappingservice/implementation/src/main/java/org/opendaylight/lispflowmapping/implementation/mdsal/AuthenticationKeyDataListener.java index e4f11d979..0fe2dac64 100644 --- a/mappingservice/implementation/src/main/java/org/opendaylight/lispflowmapping/implementation/mdsal/AuthenticationKeyDataListener.java +++ b/mappingservice/implementation/src/main/java/org/opendaylight/lispflowmapping/implementation/mdsal/AuthenticationKeyDataListener.java @@ -54,8 +54,7 @@ public class AuthenticationKeyDataListener extends AbstractDataListener { LOG.trace("Key: {}", entry.getKey()); LOG.trace("Value: {}", authkey); - msmr.addAuthenticationKey(authkey.getLispAddressContainer(), - authkey.getMaskLength(), authkey.getAuthkey()); + msmr.addAuthenticationKey(authkey.getLispAddressContainer(), authkey.getAuthkey()); } } @@ -69,8 +68,7 @@ public class AuthenticationKeyDataListener extends AbstractDataListener { LOG.trace("Key: {}", entry.getKey()); LOG.trace("Value: {}", authkey); - msmr.addAuthenticationKey(authkey.getLispAddressContainer(), - authkey.getMaskLength(), authkey.getAuthkey()); + msmr.addAuthenticationKey(authkey.getLispAddressContainer(), authkey.getAuthkey()); } } @@ -85,7 +83,7 @@ public class AuthenticationKeyDataListener extends AbstractDataListener { LOG.trace("Key: {}", entry); LOG.trace("Value: {}", authkey); - msmr.removeAuthenticationKey(authkey.getLispAddressContainer(), authkey.getMaskLength()); + msmr.removeAuthenticationKey(authkey.getLispAddressContainer()); } } } diff --git a/mappingservice/implementation/src/main/java/org/opendaylight/lispflowmapping/implementation/mdsal/DataStoreBackEnd.java b/mappingservice/implementation/src/main/java/org/opendaylight/lispflowmapping/implementation/mdsal/DataStoreBackEnd.java index 7ade05917..fad557af5 100644 --- a/mappingservice/implementation/src/main/java/org/opendaylight/lispflowmapping/implementation/mdsal/DataStoreBackEnd.java +++ b/mappingservice/implementation/src/main/java/org/opendaylight/lispflowmapping/implementation/mdsal/DataStoreBackEnd.java @@ -46,65 +46,60 @@ public class DataStoreBackEnd { public void addAuthenticationKey(AuthenticationKey authenticationKey) { LOG.debug("MD-SAL: Adding authentication key '{}' for {}", authenticationKey.getAuthkey(), - LispAddressStringifier.getString(authenticationKey.getLispAddressContainer(), - authenticationKey.getMaskLength())); + LispAddressStringifier.getString(authenticationKey.getLispAddressContainer())); InstanceIdentifier path = InstanceIdentifierUtil - .createAuthenticationKeyIid(authenticationKey.getLispAddressContainer(), - authenticationKey.getMaskLength()); + .createAuthenticationKeyIid(authenticationKey.getLispAddressContainer()); writePutTransaction(path, authenticationKey, LogicalDatastoreType.CONFIGURATION, "Adding authentication key to config datastrore failed"); } public void addMapping(Mapping mapping) { LOG.debug("MD-SAL: Adding mapping for {}", - LispAddressStringifier.getString(mapping.getLispAddressContainer(), mapping.getMaskLength())); + LispAddressStringifier.getString(mapping.getLispAddressContainer())); InstanceIdentifier path = InstanceIdentifierUtil - .createMappingIid(mapping.getLispAddressContainer(), mapping.getMaskLength(), mapping.getOrigin()); + .createMappingIid(mapping.getLispAddressContainer(), mapping.getOrigin()); writePutTransaction(path, mapping, LogicalDatastoreType.CONFIGURATION, "Adding mapping to config datastrore failed"); } public void removeAuthenticationKey(AuthenticationKey authenticationKey) { LOG.debug("MD-SAL: Removing authentication key for {}", - LispAddressStringifier.getString(authenticationKey.getLispAddressContainer(), - authenticationKey.getMaskLength())); + LispAddressStringifier.getString(authenticationKey.getLispAddressContainer())); InstanceIdentifier path = InstanceIdentifierUtil - .createAuthenticationKeyIid(authenticationKey.getLispAddressContainer(), - authenticationKey.getMaskLength()); + .createAuthenticationKeyIid(authenticationKey.getLispAddressContainer()); deleteTransaction(path, LogicalDatastoreType.CONFIGURATION, "Deleting authentication key from config datastrore failed"); } public void removeMapping(Mapping mapping) { LOG.debug("MD-SAL: Removing mapping for {}", - LispAddressStringifier.getString(mapping.getLispAddressContainer(), mapping.getMaskLength())); + LispAddressStringifier.getString(mapping.getLispAddressContainer())); InstanceIdentifier path = InstanceIdentifierUtil - .createMappingIid(mapping.getLispAddressContainer(), mapping.getMaskLength(), mapping.getOrigin()); + .createMappingIid(mapping.getLispAddressContainer(), mapping.getOrigin()); deleteTransaction(path, LogicalDatastoreType.CONFIGURATION, "Deleting mapping from config datastrore failed"); } public void updateAuthenticationKey(AuthenticationKey authenticationKey) { LOG.debug("MD-SAL: Updating authentication key for {} with '{}'", - LispAddressStringifier.getString(authenticationKey.getLispAddressContainer(), - authenticationKey.getMaskLength()), authenticationKey.getAuthkey()); + LispAddressStringifier.getString(authenticationKey.getLispAddressContainer()), + authenticationKey.getAuthkey()); InstanceIdentifier path = InstanceIdentifierUtil - .createAuthenticationKeyIid(authenticationKey.getLispAddressContainer(), - authenticationKey.getMaskLength()); + .createAuthenticationKeyIid(authenticationKey.getLispAddressContainer()); writePutTransaction(path, authenticationKey, LogicalDatastoreType.CONFIGURATION, "Updating authentication key in config datastrore failed"); } public void updateMapping(Mapping mapping) { LOG.debug("MD-SAL: Updating mapping for {}", - LispAddressStringifier.getString(mapping.getLispAddressContainer(), mapping.getMaskLength())); + LispAddressStringifier.getString(mapping.getLispAddressContainer())); InstanceIdentifier path = InstanceIdentifierUtil - .createMappingIid(mapping.getLispAddressContainer(), mapping.getMaskLength(), mapping.getOrigin()); + .createMappingIid(mapping.getLispAddressContainer(), mapping.getOrigin()); writePutTransaction(path, mapping, LogicalDatastoreType.CONFIGURATION, "Updating mapping in config datastrore failed"); } diff --git a/mappingservice/implementation/src/main/java/org/opendaylight/lispflowmapping/implementation/mdsal/MappingDataListener.java b/mappingservice/implementation/src/main/java/org/opendaylight/lispflowmapping/implementation/mdsal/MappingDataListener.java index f2138c96e..84185db9c 100644 --- a/mappingservice/implementation/src/main/java/org/opendaylight/lispflowmapping/implementation/mdsal/MappingDataListener.java +++ b/mappingservice/implementation/src/main/java/org/opendaylight/lispflowmapping/implementation/mdsal/MappingDataListener.java @@ -99,7 +99,7 @@ public class MappingDataListener extends AbstractDataListener { LOG.trace("Key: {}", entry); LOG.trace("Value: {}", dataObject); - msmr.removeMapping(mapping.getLispAddressContainer(), mapping.getMaskLength()); + msmr.removeMapping(mapping.getLispAddressContainer()); } } } diff --git a/mappingservice/implementation/src/main/java/org/opendaylight/lispflowmapping/implementation/util/DAOMappingUtil.java b/mappingservice/implementation/src/main/java/org/opendaylight/lispflowmapping/implementation/util/DAOMappingUtil.java deleted file mode 100644 index a2d5d6a55..000000000 --- a/mappingservice/implementation/src/main/java/org/opendaylight/lispflowmapping/implementation/util/DAOMappingUtil.java +++ /dev/null @@ -1,549 +0,0 @@ -/* - * 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.implementation.util; - -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.MappingKeyUtil; -import org.opendaylight.lispflowmapping.interfaces.dao.ILispDAO; -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.lisp.proto.rev150820.LispAFIAddress; -import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev150820.eidrecords.EidRecord; -import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev150820.eidtolocatorrecords.EidToLocatorRecord; -import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev150820.lcafsourcedestaddress.DstAddressBuilder; -import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev150820.lcafsourcedestaddress.SrcAddressBuilder; -import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev150820.lispaddress.LispAddressContainer; -import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev150820.lispaddress.lispaddresscontainer.Address; -import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev150820.lispaddress.lispaddresscontainer.address.LcafKeyValue; -import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev150820.lispaddress.lispaddresscontainer.address.LcafSourceDest; -import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev150820.lispaddress.lispaddresscontainer.address.lcafsourcedest.LcafSourceDestAddr; -import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev150820.lispaddress.lispaddresscontainer.address.lcafsourcedest.LcafSourceDestAddrBuilder; -import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev150820.lispsimpleaddress.primitiveaddress.DistinguishedName; -import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev150820.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 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) { - IMappingKey key = MappingKeyUtil.generateMappingKey(eid.getLispAddressContainer(), eid.getMask()); - return getLocatorsSpecific(key, dao, subkey, iterateMask); - } - - public static List 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) { - IMappingKey key = MappingKeyUtil.generateMappingKey(eid.getLispAddressContainer(), eid.getMaskLength()); - return getLocatorsSpecific(key, dao, subkey, iterateMask); - } - - public static List getLocators(IMappingKey key, ILispDAO dao, boolean iterateMask) { - Map locators = dao.get(key); - List 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 aggregateLocators(Map locators) { - List result = new ArrayList(); - if (locators != null) { - for (Object value : locators.values()) { - if (value != null && value instanceof RLOCGroup) { - result.add((RLOCGroup) value); - } - } - } - return result; - } - - 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)) { - locators = findMaskLocatorsSpecific(key, dao, subkey); - } - return locators; - } - - private static Object findMaskLocatorsSpecific(IMappingKey key, ILispDAO dao, String subkey) { - int mask = key.getMask(); - while (mask > 0) { - LispAFIAddress eid = LispAFIConvertor.toAFI(key.getEID()); - key = MappingKeyUtil.generateMappingKey(LispAFIConvertor.toContainer(MaskUtil.normalize(eid, mask)), mask); - mask--; - Object locators = dao.getSpecific(key, subkey); - if (locators != null) { - return locators; - } - } - return null; - } - - private static List findMaskLocators(ILispDAO dao, IMappingKey key) { - int mask = key.getMask(); - while (mask > 0) { - LispAFIAddress eid = LispAFIConvertor.toAFI(key.getEID()); - key = MappingKeyUtil.generateMappingKey(LispAFIConvertor.toContainer(MaskUtil.normalize(eid, mask)), mask); - mask--; - Map locators = dao.get(key); - if (locators != null) { - List result = aggregateLocators(locators); - if (result != null && !result.isEmpty()) { - return result; - } - } - } - return null; - } - - public static Entry> getMapping(LispAFIAddress srcEid, EidRecord eidRecord, - ILispDAO dao) { - // a map-request for an actual SrcDst LCAF, ignore src eid - 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> 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(); - IMappingKey newKey = MappingKeyUtil.generateMappingKey( - LispAFIConvertor.toAFIfromPrimitive(srcDst.getDstAddress().getPrimitiveAddress()), - srcDst.getDstMaskLength()); - return new AbstractMap.SimpleImmutableEntry<>(newKey, mapping.getValue()); - } - - return mapping; - } - - public static Entry> getMapping(LispAFIAddress srcEid, LispAFIAddress dstEid, - short srcMask, short dstMask, ILispDAO dao) { - IMappingKey key = MappingKeyUtil.generateMappingKey(dstEid, dstMask); - Entry> daoEntry = getDaoEntry(key, dao); - if (daoEntry != null) { - // try SrcDst eid lookup - ILispDAO srcDstDao = (ILispDAO) daoEntry.getValue().get(DAOSubKeys.LCAF_SRCDST_SUBKEY.toString()); - if (srcDstDao != null) { - Entry> 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(); - IMappingKey newKey = MappingKeyUtil.generateMappingKey(newEid, dstMask); - return new AbstractMap.SimpleImmutableEntry<>(newKey, mapping.getValue()); - } - } - - // dst eid lookup - return makeMappingEntry(daoEntry.getKey(), daoEntry.getValue()); - } - return new AbstractMap.SimpleImmutableEntry<>(key, null); - } - - public static Entry> getMappingExact(LispAFIAddress srcEid, LispAFIAddress dstEid, - short srcMask, short dstMask, ILispDAO dao) { - IMappingKey dstKey = MappingKeyUtil.generateMappingKey(dstEid, dstMask); - Map daoEntry = dao.get(dstKey); - if (daoEntry != null) { - // try SrcDst eid lookup - ILispDAO srcDstDao = (ILispDAO) daoEntry.get(DAOSubKeys.LCAF_SRCDST_SUBKEY.toString()); - // if lookup fails, return whatever is found for dst eid - if (srcDstDao != null) { - IMappingKey srcKey = MappingKeyUtil.generateMappingKey(srcEid, srcMask); - Map 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(); - IMappingKey newKey = MappingKeyUtil.generateMappingKey(newEid, dstMask); - return makeMappingEntry(newKey, mapping); - } - - // dst eid lookup - return makeMappingEntry(dstKey, daoEntry); - } - return new AbstractMap.SimpleImmutableEntry<>(dstKey, null); - } - - public static Entry> getMappingForEidRecord(EidRecord eid, ILispDAO dao) { - return getMappingForEid(LispAFIConvertor.toAFI(eid.getLispAddressContainer()), eid.getMask(), dao); - } - - private static Entry> makeMappingEntry(IMappingKey key, Map locators) { - if (locators != null) { - List locatorsList = aggregateLocators(locators); - if (locatorsList != null && !locatorsList.isEmpty()) { - return new AbstractMap.SimpleImmutableEntry<>(key, locatorsList); - } - } - return new AbstractMap.SimpleImmutableEntry<>(key, null); - } - - public static Entry> 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()); - - return getMapping(srcAddr, dstAddr, ((LcafSourceDestAddr) eid).getSrcMaskLength(), - ((LcafSourceDestAddr) eid).getDstMaskLength(), dao); - } - IMappingKey key = MappingKeyUtil.generateMappingKey(eid, maskLen); - Entry> entry = getDaoEntry(key, dao); - if (entry == null) { - return makeMappingEntry(key, null); - } else { - return makeMappingEntry(entry.getKey(), entry.getValue()); - } - } - - public static Entry> getDaoEntry(IMappingKey lookupKey, ILispDAO dao) { - LispAFIAddress eidAddress = LispAFIConvertor.toAFI(lookupKey.getEID()); - if (MaskUtil.isMaskable(eidAddress)) { - IMappingKey key; - int mask = lookupKey.getMask(); - while (mask > 0) { - key = MappingKeyUtil.generateMappingKey(eidAddress, mask); - mask--; - Map entry = dao.get(key); - if (entry != null) { - return new AbstractMap.SimpleImmutableEntry>(key, entry); - } - } - return null; - } else { - Map entry = dao.get(lookupKey); - if (entry != null) { - return new AbstractMap.SimpleImmutableEntry>(lookupKey, - dao.get(lookupKey)); - } else { - return null; - } - } - } - - public static void addSubscribers(LispAddressContainer eid, int mask, Set subscribers, - ILispDAO dao) { - IMappingKey key = MappingKeyUtil.generateMappingKey(eid, mask); - dao.put(key, new MappingEntry>(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(DAOSubKeys.PASSWORD_SUBKEY.toString(), key)); - } else { - dao.put(mappingServiceKey, new MappingEntry(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 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) 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 rlocGroups = new HashMap(); - 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> entries = new ArrayList<>(); - for (String subkey : rlocGroups.keySet()) { - entries.add(new MappingEntry<>(subkey, rlocGroups.get(subkey))); - } - - if (eidRecord.getLispAddressContainer().getAddress() instanceof LcafSourceDest) { - Entry> 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 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> 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> 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> 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> 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(); - } - -} diff --git a/mappingservice/implementation/src/main/java/org/opendaylight/lispflowmapping/implementation/util/DAOSubKeys.java b/mappingservice/implementation/src/main/java/org/opendaylight/lispflowmapping/implementation/util/DAOSubKeys.java deleted file mode 100644 index d5c8e5606..000000000 --- a/mappingservice/implementation/src/main/java/org/opendaylight/lispflowmapping/implementation/util/DAOSubKeys.java +++ /dev/null @@ -1,39 +0,0 @@ -/* - * 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; - } - -} diff --git a/mappingservice/implementation/src/main/java/org/opendaylight/lispflowmapping/implementation/util/InstanceIdentifierUtil.java b/mappingservice/implementation/src/main/java/org/opendaylight/lispflowmapping/implementation/util/InstanceIdentifierUtil.java index b25378187..f705718b3 100644 --- a/mappingservice/implementation/src/main/java/org/opendaylight/lispflowmapping/implementation/util/InstanceIdentifierUtil.java +++ b/mappingservice/implementation/src/main/java/org/opendaylight/lispflowmapping/implementation/util/InstanceIdentifierUtil.java @@ -33,20 +33,20 @@ import com.google.common.base.Preconditions; * */ public class InstanceIdentifierUtil { - public static InstanceIdentifier createAuthenticationKeyIid(LispAddressContainer eid, int mask) { + public static InstanceIdentifier createAuthenticationKeyIid(LispAddressContainer eid) { Preconditions.checkNotNull(eid, "Key needs and EID entry!"); InstanceIdKey iidKey = new InstanceIdKey(new IidUri(Long.toString(getLispInstanceId(eid)))); - AuthenticationKeyKey authKeyKey = new AuthenticationKeyKey(new EidUri(getURIAddressString(eid, mask))); + AuthenticationKeyKey authKeyKey = new AuthenticationKeyKey(new EidUri(getURIAddressString(eid))); return InstanceIdentifier.create(MappingDatabase.class) .child(InstanceId.class, iidKey).child(AuthenticationKey.class, authKeyKey); } - public static InstanceIdentifier createMappingIid(LispAddressContainer eid, int mask, MappingOrigin orig) { + public static InstanceIdentifier createMappingIid(LispAddressContainer eid, MappingOrigin orig) { Preconditions.checkNotNull(eid, "Mapping needs an EID entry!"); InstanceIdKey iidKey = new InstanceIdKey(new IidUri(Long.toString(getLispInstanceId(eid)))); - MappingKey eidKey = new MappingKey(new EidUri(getURIAddressString(eid, mask)), orig); + MappingKey eidKey = new MappingKey(new EidUri(getURIAddressString(eid)), orig); return InstanceIdentifier.create(MappingDatabase.class) .child(InstanceId.class, iidKey).child(Mapping.class, eidKey); } @@ -59,7 +59,7 @@ public class InstanceIdentifierUtil { return 0L; } - private static String getURIAddressString(LispAddressContainer container, int mask) { - return LispAddressStringifier.getURIString(container, mask); + private static String getURIAddressString(LispAddressContainer container) { + return LispAddressStringifier.getURIString(container); } } diff --git a/mappingservice/implementation/src/main/java/org/opendaylight/lispflowmapping/implementation/util/LispNotificationHelper.java b/mappingservice/implementation/src/main/java/org/opendaylight/lispflowmapping/implementation/util/LispNotificationHelper.java index 3a9fa448a..64a36a667 100644 --- a/mappingservice/implementation/src/main/java/org/opendaylight/lispflowmapping/implementation/util/LispNotificationHelper.java +++ b/mappingservice/implementation/src/main/java/org/opendaylight/lispflowmapping/implementation/util/LispNotificationHelper.java @@ -86,7 +86,7 @@ public class LispNotificationHelper { EidToLocatorRecord record = mapRegisterNotification.getMapRegister().getEidToLocatorRecord().get(i); MappingBuilder mb = new MappingBuilder(); mb.setEid(new EidUri(LispAddressStringifier.getURIString( - record.getLispAddressContainer(), record.getMaskLength()))); + record.getLispAddressContainer()))); mb.setOrigin(MappingOrigin.Southbound); mb.setSiteId(getSiteId(mapRegisterNotification.getMapRegister())); mb.setRecordTtl(record.getRecordTtl()); diff --git a/mappingservice/implementation/src/main/java/org/opendaylight/lispflowmapping/implementation/util/MaskUtil.java b/mappingservice/implementation/src/main/java/org/opendaylight/lispflowmapping/implementation/util/MaskUtil.java deleted file mode 100644 index 7eb366923..000000000 --- a/mappingservice/implementation/src/main/java/org/opendaylight/lispflowmapping/implementation/util/MaskUtil.java +++ /dev/null @@ -1,108 +0,0 @@ -/* - * 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.implementation.util; - -import java.net.Inet4Address; -import java.net.Inet6Address; -import java.net.InetAddress; -import java.net.UnknownHostException; -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.lisp.proto.rev150820.LispAFIAddress; -import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev150820.lcafsegmentaddress.AddressBuilder; -import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev150820.lcafsegmentaddress.Address; -import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev150820.lispaddress.lispaddresscontainer.address.ipv4.Ipv4Address; -import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev150820.lispaddress.lispaddresscontainer.address.ipv6.Ipv6Address; -import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev150820.lispaddress.lispaddresscontainer.address.lcafsegment.LcafSegmentAddr; -import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev150820.lispaddress.lispaddresscontainer.address.lcafsegment.LcafSegmentAddrBuilder; -import org.slf4j.Logger; -import org.slf4j.LoggerFactory; - -public class MaskUtil { - private static final Logger LOG = LoggerFactory.getLogger(MaskUtil.class); - public static boolean isMaskable(LispAFIAddress address) { - if (address instanceof Ipv4Address || address instanceof Ipv6Address - || address instanceof LcafSegmentAddr) { - return true; - } - return false; - } - - public static LispAFIAddress normalize(LispAFIAddress address, int mask) { - try { - if (address instanceof Ipv4Address) { - return LispAFIConvertor.asIPAfiAddress(normalizeIP(Inet4Address.getByName(((Ipv4Address) address) - .getIpv4Address().getValue()), mask).getHostAddress()); - } else if (address instanceof Ipv6Address) { - return LispAFIConvertor.asIPv6AfiAddress(normalizeIP(Inet6Address.getByName(((Ipv6Address) address) - .getIpv6Address().getValue()), mask).getHostAddress()); - } else if (address instanceof LcafSegmentAddr) { - LcafSegmentAddr segAddr = (LcafSegmentAddr) address; - Address normalizedAddr = new AddressBuilder().setPrimitiveAddress(LispAFIConvertor.toPrimitive( - normalizeIpAddress(LispAFIConvertor.toAFIfromPrimitive(segAddr.getAddress() - .getPrimitiveAddress()), mask))).build(); - return new LcafSegmentAddrBuilder(segAddr).setAddress(normalizedAddr).build(); - } - } catch (UnknownHostException e) { - LOG.trace("Failed to normalize " + address + ": " + ExceptionUtils.getStackTrace(e)); - return null; - } - return null; - } - - private static LispAFIAddress normalizeIpAddress(LispAFIAddress address, int mask) throws UnknownHostException { - if (address instanceof Ipv4Address) { - return LispAFIConvertor.asIPAfiAddress(normalizeIP(Inet4Address.getByName(((Ipv4Address) address) - .getIpv4Address().getValue()), mask).getHostAddress()); - } else if (address instanceof Ipv6Address) { - return LispAFIConvertor.asIPv6AfiAddress(normalizeIP(Inet6Address.getByName(((Ipv6Address) address) - .getIpv6Address().getValue()), mask).getHostAddress()); - } - throw new UnknownHostException("Address + " + address + " not an IPv4 or IPv6 address"); - } - - private static InetAddress normalizeIP(InetAddress address, int mask) throws UnknownHostException { - ByteBuffer byteRepresentation = ByteBuffer.wrap(address.getAddress()); - byte b = (byte) 0xff; - for (int i = 0; i < byteRepresentation.array().length; i++) { - if (mask >= 8) - byteRepresentation.put(i, (byte) (b & byteRepresentation.get(i))); - - else if (mask > 0) { - byteRepresentation.put(i, (byte) ((byte) (b << (8 - mask)) & byteRepresentation.get(i))); - } else { - byteRepresentation.put(i, (byte) (0 & byteRepresentation.get(i))); - } - - mask -= 8; - } - return InetAddress.getByAddress(byteRepresentation.array()); - } - - public static int getMaxMask(LispAFIAddress address) { - if (address instanceof Ipv4Address) { - return 32; - } - if (address instanceof Ipv6Address) { - return 128; - } - return -1; - } - - public static byte getMaxMaskForAfi(int afi) { - if (afi == 1) { - return (byte) 32; - } else if (afi == 2){ - return (byte) 128; - } else { - return (byte) -1; - } - } -} diff --git a/mappingservice/implementation/src/main/java/org/opendaylight/lispflowmapping/implementation/util/RPCInputConvertorUtil.java b/mappingservice/implementation/src/main/java/org/opendaylight/lispflowmapping/implementation/util/RPCInputConvertorUtil.java index 9d62b1458..5629a8c70 100644 --- a/mappingservice/implementation/src/main/java/org/opendaylight/lispflowmapping/implementation/util/RPCInputConvertorUtil.java +++ b/mappingservice/implementation/src/main/java/org/opendaylight/lispflowmapping/implementation/util/RPCInputConvertorUtil.java @@ -31,7 +31,7 @@ public class RPCInputConvertorUtil { public static AuthenticationKey toAuthenticationKey(AddKeyInput input) { AuthenticationKeyBuilder akb = new AuthenticationKeyBuilder(); akb.setEid(new EidUri(LispAddressStringifier.getURIString( - input.getLispAddressContainer(), input.getMaskLength()))); + input.getLispAddressContainer()))); akb.setLispAddressContainer(input.getLispAddressContainer()); akb.setMaskLength(input.getMaskLength()); akb.setKeyType(input.getKeyType()); @@ -42,7 +42,7 @@ public class RPCInputConvertorUtil { public static AuthenticationKey toAuthenticationKey(UpdateKeyInput input) { AuthenticationKeyBuilder akb = new AuthenticationKeyBuilder(); akb.setEid(new EidUri(LispAddressStringifier.getURIString( - input.getEid().getLispAddressContainer(), input.getEid().getMaskLength()))); + input.getEid().getLispAddressContainer()))); akb.setLispAddressContainer(input.getEid().getLispAddressContainer()); akb.setMaskLength(input.getEid().getMaskLength()); akb.setKeyType(input.getKey().getKeyType()); @@ -53,7 +53,7 @@ public class RPCInputConvertorUtil { public static AuthenticationKey toAuthenticationKey(RemoveKeyInput input) { AuthenticationKeyBuilder akb = new AuthenticationKeyBuilder(); akb.setEid(new EidUri(LispAddressStringifier.getURIString( - input.getLispAddressContainer(), input.getMaskLength()))); + input.getLispAddressContainer()))); akb.setLispAddressContainer(input.getLispAddressContainer()); akb.setMaskLength(input.getMaskLength()); return akb.build(); @@ -62,7 +62,7 @@ public class RPCInputConvertorUtil { public static Mapping toMapping(AddMappingInput input) { MappingBuilder mb = new MappingBuilder(); mb.setEid(new EidUri(LispAddressStringifier.getURIString( - input.getLispAddressContainer(), input.getMaskLength()))); + input.getLispAddressContainer()))); mb.setOrigin(MappingOrigin.Northbound); mb.setRecordTtl(input.getRecordTtl()); mb.setMaskLength(input.getMaskLength()); @@ -77,7 +77,7 @@ public class RPCInputConvertorUtil { public static Mapping toMapping(UpdateMappingInput input) { MappingBuilder mb = new MappingBuilder(); mb.setEid(new EidUri(LispAddressStringifier.getURIString( - input.getLispAddressContainer(), input.getMaskLength()))); + input.getLispAddressContainer()))); mb.setOrigin(MappingOrigin.Northbound); mb.setRecordTtl(input.getRecordTtl()); mb.setMaskLength(input.getMaskLength()); @@ -92,7 +92,7 @@ public class RPCInputConvertorUtil { public static Mapping toMapping(RemoveMappingInput input) { MappingBuilder mb = new MappingBuilder(); mb.setEid(new EidUri(LispAddressStringifier.getURIString( - input.getLispAddressContainer(), input.getMaskLength()))); + input.getLispAddressContainer()))); mb.setOrigin(MappingOrigin.Northbound); mb.setMaskLength(input.getMaskLength()); mb.setLispAddressContainer(input.getLispAddressContainer()); diff --git a/mappingservice/implementation/src/test/java/org/opendaylight/lispflowmapping/implementation/lisp/MapResolverTest.java b/mappingservice/implementation/src/test/java/org/opendaylight/lispflowmapping/implementation/lisp/MapResolverTest.java index 7686f4bf6..160edf419 100644 --- a/mappingservice/implementation/src/test/java/org/opendaylight/lispflowmapping/implementation/lisp/MapResolverTest.java +++ b/mappingservice/implementation/src/test/java/org/opendaylight/lispflowmapping/implementation/lisp/MapResolverTest.java @@ -11,7 +11,6 @@ import static org.junit.Assert.assertEquals; import java.util.ArrayList; import java.util.HashMap; -import java.util.List; import java.util.Map; import org.jmock.api.Invocation; @@ -19,21 +18,18 @@ import org.junit.Assert; import org.junit.Before; import org.junit.Test; import org.opendaylight.lispflowmapping.implementation.LispMappingService; -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.IMappingKey; -import org.opendaylight.lispflowmapping.interfaces.dao.RLOCGroup; +import org.opendaylight.lispflowmapping.interfaces.dao.SubKeys; import org.opendaylight.lispflowmapping.lisp.util.LispAFIConvertor; import org.opendaylight.lispflowmapping.tools.junit.BaseTestCase; import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev150820.EidToLocatorRecord.Action; -import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev150820.LispAFIAddress; import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev150820.MapReply; import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev150820.MapRequest; import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev150820.eidrecords.EidRecord; import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev150820.eidrecords.EidRecordBuilder; import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev150820.eidtolocatorrecords.EidToLocatorRecord; import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev150820.eidtolocatorrecords.EidToLocatorRecordBuilder; +import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev150820.lispaddress.LispAddressContainer; import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev150820.locatorrecords.LocatorRecord; import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev150820.locatorrecords.LocatorRecordBuilder; import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev150820.maprequest.ItrRloc; @@ -47,10 +43,10 @@ public class MapResolverTest extends BaseTestCase { private ILispDAO lispDAO; private MapRequestBuilder mapRequest; - private LispAFIAddress v4Address; - private LispAFIAddress v6Address; + private LispAddressContainer v4Address; + private LispAddressContainer v6Address; - private HashMap> daoResults; + private HashMap> daoResults; @Override @Before @@ -61,9 +57,9 @@ public class MapResolverTest extends BaseTestCase { testedMapResolver.basicInit(lispDAO); mapRequest = new MapRequestBuilder(); - v4Address = LispAFIConvertor.asIPAfiAddress("1.2.3.4"); - v6Address = LispAFIConvertor.asIPv6AfiAddress("0:0:0:0:0:0:0:1"); - daoResults = new HashMap>(); + v4Address = LispAFIConvertor.asIPv4Address("1.2.3.4"); + v6Address = LispAFIConvertor.asIPv6Address("0:0:0:0:0:0:0:1"); + daoResults = new HashMap>(); } @Test @@ -71,14 +67,14 @@ public class MapResolverTest extends BaseTestCase { mapRequest = getDefaultMapRequestBuilder(); mapRequest.getEidRecord().add( new EidRecordBuilder().setMask((short) 32) - .setLispAddressContainer(LispAFIConvertor.toContainer(LispAFIConvertor.asIPAfiAddress("1.2.3.4"))).build()); + .setLispAddressContainer(LispAFIConvertor.asIPv4Address("1.2.3.4")).build()); EidToLocatorRecordBuilder record = getDefaultEidToLocatorBuilder(); - record.setLispAddressContainer(LispAFIConvertor.toContainer(v4Address)); + record.setLispAddressContainer(v4Address); LocatorRecordBuilder locator = getDefaultLocatorBuilder(); locator.setLocalLocator(false); - locator.setLispAddressContainer(LispAFIConvertor.toContainer(LispAFIConvertor.asIPAfiAddress("4.3.2.1"))); + locator.setLispAddressContainer(LispAFIConvertor.asIPv4Address("4.3.2.1")); locator.setRouted(true); locator.setMulticastPriority((short) 5); locator.setWeight((short) 17); @@ -98,22 +94,22 @@ public class MapResolverTest extends BaseTestCase { assertEquals(locator.getPriority(), resultLocator.getPriority()); assertEquals(locator.getWeight(), resultLocator.getWeight()); - assertLocator(LispAFIConvertor.asIPAfiAddress("4.3.2.1"), eidToLocators.getLocatorRecord().get(0)); + assertLocator(LispAFIConvertor.asIPv4Address("4.3.2.1"), eidToLocators.getLocatorRecord().get(0)); } @Test public void handleMapRequest__VerifyBasicFields() throws Exception { mapRequest = getDefaultMapRequestBuilder(); mapRequest.getEidRecord().add( - new EidRecordBuilder().setMask((short) 32).setLispAddressContainer(LispAFIConvertor.toContainer(v4Address)).build()); + new EidRecordBuilder().setMask((short) 32).setLispAddressContainer(v4Address).build()); EidToLocatorRecordBuilder record = getDefaultEidToLocatorBuilder(); - record.setLispAddressContainer(LispAFIConvertor.toContainer(v4Address)); + record.setLispAddressContainer(v4Address); record.setRecordTtl(100); record.setAuthoritative(true); LocatorRecordBuilder locator = getDefaultLocatorBuilder(); - locator.setLispAddressContainer(LispAFIConvertor.toContainer(LispAFIConvertor.asIPAfiAddress("4.3.2.1"))); + locator.setLispAddressContainer(LispAFIConvertor.asIPv4Address("4.3.2.1")); record.getLocatorRecord().add(locator.build()); prepareMapping(record.build()); @@ -122,7 +118,7 @@ public class MapResolverTest extends BaseTestCase { assertEquals(mapRequest.getNonce(), mapReply.getNonce()); EidToLocatorRecord eidToLocators = mapReply.getEidToLocatorRecord().get(0); assertEquals((byte) 32, eidToLocators.getMaskLength().byteValue()); - assertEquals(v4Address, LispAFIConvertor.toAFI(eidToLocators.getLispAddressContainer())); + assertEquals(v4Address, eidToLocators.getLispAddressContainer()); assertEquals(record.isAuthoritative(), eidToLocators.isAuthoritative()); assertEquals(record.getAction(), eidToLocators.getAction()); assertEquals(record.getRecordTtl(), eidToLocators.getRecordTtl()); @@ -132,10 +128,10 @@ public class MapResolverTest extends BaseTestCase { public void handleMapRequest__VerifyMask() throws Exception { mapRequest = getDefaultMapRequestBuilder(); mapRequest.getEidRecord().add( - new EidRecordBuilder().setMask((short) 32).setLispAddressContainer(LispAFIConvertor.toContainer(v4Address)).build()); + new EidRecordBuilder().setMask((short) 32).setLispAddressContainer(v4Address).build()); EidToLocatorRecordBuilder record = getDefaultEidToLocatorBuilder(); - record.setLispAddressContainer(LispAFIConvertor.toContainer(LispAFIConvertor.asIPAfiAddress("1.2.3.0"))); + record.setLispAddressContainer(LispAFIConvertor.asIPv4Prefix("1.2.3.0", 24)); record.setMaskLength((short) 24); LocatorRecordBuilder locator = getDefaultLocatorBuilder(); @@ -144,20 +140,19 @@ public class MapResolverTest extends BaseTestCase { prepareMapping(record.build()); MapRequest mr = mapRequest.build(); - MapReply mapReply = testedMapResolver.handleMapRequest(mr); assertEquals(mr.getNonce(), mapReply.getNonce()); EidToLocatorRecord eidToLocators = mapReply.getEidToLocatorRecord().get(0); assertEquals((byte) 24, eidToLocators.getMaskLength().byteValue()); - assertEquals(LispAFIConvertor.asIPAfiAddress("1.2.3.0"), LispAFIConvertor.toAFI(eidToLocators.getLispAddressContainer())); + assertEquals(LispAFIConvertor.asIPv4Prefix("1.2.3.0", 24), eidToLocators.getLispAddressContainer()); } @Test public void handleMapRequest__VerifyMaskIPv6() throws Exception { mapRequest = getDefaultMapRequestBuilder(); mapRequest.getEidRecord().add( - new EidRecordBuilder().setMask((short) 128).setLispAddressContainer(LispAFIConvertor.toContainer(v6Address)).build()); + new EidRecordBuilder().setMask((short) 128).setLispAddressContainer(v6Address).build()); EidToLocatorRecordBuilder record = getDefaultEidToLocatorBuilder(); record.setLispAddressContainer(LispAFIConvertor.toContainer(LispAFIConvertor.asIPv6AfiAddress("0:0:0:0:0:0:0:0"))); @@ -175,21 +170,21 @@ public class MapResolverTest extends BaseTestCase { assertEquals(mr.getNonce(), mapReply.getNonce()); EidToLocatorRecord eidToLocators = mapReply.getEidToLocatorRecord().get(0); assertEquals((byte) 128, eidToLocators.getMaskLength().byteValue()); - assertEquals(v6Address, LispAFIConvertor.toAFI(eidToLocators.getLispAddressContainer())); + assertEquals(v6Address, eidToLocators.getLispAddressContainer()); } @Test public void handleMapRequest__VerifyMaskIPv6NoMatch() throws Exception { mapRequest = getDefaultMapRequestBuilder(); mapRequest.getEidRecord().add( - new EidRecordBuilder().setMask((short) 128).setLispAddressContainer(LispAFIConvertor.toContainer(v6Address)).build()); + new EidRecordBuilder().setMask((short) 128).setLispAddressContainer(v6Address).build()); EidToLocatorRecordBuilder record = getDefaultEidToLocatorBuilder(); - record.setLispAddressContainer(LispAFIConvertor.toContainer(LispAFIConvertor.asIPv6AfiAddress("0:1:0:0:0:0:0:1"))); + record.setLispAddressContainer(LispAFIConvertor.asIPv6Prefix("0:1:0:0:0:0:0:1", 112)); record.setMaskLength((short) 112); LocatorRecordBuilder locator = getDefaultLocatorBuilder(); - locator.setLispAddressContainer(LispAFIConvertor.toContainer(LispAFIConvertor.asIPAfiAddress("4.3.2.1"))); + locator.setLispAddressContainer(LispAFIConvertor.asIPv4Address("4.3.2.1")); record.getLocatorRecord().add(locator.build()); prepareMapping(record.build()); @@ -197,15 +192,15 @@ public class MapResolverTest extends BaseTestCase { MapReply mapReply = testedMapResolver.handleMapRequest(mr); EidToLocatorRecord eidToLocators = mapReply.getEidToLocatorRecord().get(0); - assertEquals(0, eidToLocators.getLocatorRecord().size()); + assertEquals(null, eidToLocators.getLocatorRecord()); } @Test public void handleMapRequest_VerifyNativelyForwardAutherized() { MapRequest mr = getDefaultMapRequest(); - Map> result = new HashMap>(); - result.put(DAOSubKeys.ADDRESS_SUBKEY.toString(), new ArrayList()); + Map result = new HashMap(); + result.put(SubKeys.RECORD, null); MapReply mapReply = getNativelyForwardMapReply(mr, result); @@ -214,10 +209,10 @@ public class MapResolverTest extends BaseTestCase { assertEquals(Action.NativelyForward, eidToLocators.getAction()); } - private MapReply getNativelyForwardMapReply(MapRequest mr, Map> result) { - allowing(lispDAO).get(wany(IMappingKey.class)); + private MapReply getNativelyForwardMapReply(MapRequest mr, Map result) { + allowing(lispDAO).get(wany(LispAddressContainer.class)); ret(result); - allowing(lispDAO).getSpecific(wany(IMappingKey.class), with(DAOSubKeys.PASSWORD_SUBKEY.toString())); + allowing(lispDAO).getSpecific(wany(LispAddressContainer.class), with(SubKeys.PASSWORD)); ret("pass"); MapReply mapReply = testedMapResolver.handleMapRequest(mr); return mapReply; @@ -226,7 +221,7 @@ public class MapResolverTest extends BaseTestCase { private MapRequest getDefaultMapRequest() { mapRequest = getDefaultMapRequestBuilder(); mapRequest.getEidRecord().add( - new EidRecordBuilder().setMask((short) 32).setLispAddressContainer(LispAFIConvertor.toContainer(v4Address)).build()); + new EidRecordBuilder().setMask((short) 32).setLispAddressContainer(v4Address).build()); MapRequest mr = mapRequest.build(); return mr; } @@ -236,14 +231,14 @@ public class MapResolverTest extends BaseTestCase { mapRequest = getDefaultMapRequestBuilder(); mapRequest.getEidRecord().add( - new EidRecordBuilder().setMask((short) 32).setLispAddressContainer(LispAFIConvertor.toContainer(v4Address)).build()); + new EidRecordBuilder().setMask((short) 32).setLispAddressContainer(v4Address).build()); EidToLocatorRecordBuilder record = getDefaultEidToLocatorBuilder(); - record.setLispAddressContainer(LispAFIConvertor.toContainer(LispAFIConvertor.asIPAfiAddress("1.2.4.0"))); + record.setLispAddressContainer(LispAFIConvertor.asIPv4Prefix("1.2.4.0", 24)); record.setMaskLength((short) 24); LocatorRecordBuilder locator = getDefaultLocatorBuilder(); - locator.setLispAddressContainer(LispAFIConvertor.toContainer(LispAFIConvertor.asIPAfiAddress("4.3.2.1"))); + locator.setLispAddressContainer(LispAFIConvertor.asIPv4Address("4.3.2.1")); record.getLocatorRecord().add(locator.build()); prepareMapping(record.build()); @@ -252,8 +247,7 @@ public class MapResolverTest extends BaseTestCase { MapReply mapReply = testedMapResolver.handleMapRequest(mr); EidToLocatorRecord eidToLocators = mapReply.getEidToLocatorRecord().get(0); - assertEquals(0, eidToLocators.getLocatorRecord().size()); - + assertEquals(null, eidToLocators.getLocatorRecord()); } @Test @@ -261,19 +255,19 @@ public class MapResolverTest extends BaseTestCase { mapRequest = getDefaultMapRequestBuilder(); mapRequest.getEidRecord().add( - new EidRecordBuilder().setMask((short) 32).setLispAddressContainer(LispAFIConvertor.toContainer(v4Address)).build()); + new EidRecordBuilder().setMask((short) 32).setLispAddressContainer(v4Address).build()); EidToLocatorRecordBuilder record = getDefaultEidToLocatorBuilder(); - record.setLispAddressContainer(LispAFIConvertor.toContainer(v4Address)); + record.setLispAddressContainer(v4Address); LocatorRecordBuilder locator = getDefaultLocatorBuilder(); - locator.setLispAddressContainer(LispAFIConvertor.toContainer(LispAFIConvertor.asIPAfiAddress("4.3.2.1"))); + locator.setLispAddressContainer(LispAFIConvertor.asIPv4Address("4.3.2.1")); record.getLocatorRecord().add(locator.build()); locator = getDefaultLocatorBuilder(); - locator.setLispAddressContainer(LispAFIConvertor.toContainer(LispAFIConvertor.asIPv6AfiAddress("0:0:0:0:0:0:0:1"))); + locator.setLispAddressContainer(LispAFIConvertor.asIPv6Address("0:0:0:0:0:0:0:1")); record.getLocatorRecord().add(locator.build()); locator = getDefaultLocatorBuilder(); - locator.setLispAddressContainer(LispAFIConvertor.toContainer(LispAFIConvertor.asIPAfiAddress("1.8.2.7"))); + locator.setLispAddressContainer(LispAFIConvertor.asIPv4Address("1.8.2.7")); record.getLocatorRecord().add(locator.build()); prepareMapping(record.build()); @@ -283,9 +277,9 @@ public class MapResolverTest extends BaseTestCase { EidToLocatorRecord eidToLocators = mapReply.getEidToLocatorRecord().get(0); assertEquals(3, eidToLocators.getLocatorRecord().size()); - assertLocator(LispAFIConvertor.asIPAfiAddress("4.3.2.1"), eidToLocators.getLocatorRecord().get(0)); - assertLocator(LispAFIConvertor.asIPv6AfiAddress("0:0:0:0:0:0:0:1"), eidToLocators.getLocatorRecord().get(1)); - assertLocator(LispAFIConvertor.asIPAfiAddress("1.8.2.7"), eidToLocators.getLocatorRecord().get(2)); + assertLocator(LispAFIConvertor.asIPv4Address("4.3.2.1"), eidToLocators.getLocatorRecord().get(0)); + assertLocator(LispAFIConvertor.asIPv6Address("0:0:0:0:0:0:0:1"), eidToLocators.getLocatorRecord().get(1)); + assertLocator(LispAFIConvertor.asIPv4Address("1.8.2.7"), eidToLocators.getLocatorRecord().get(2)); } @Test @@ -293,12 +287,12 @@ public class MapResolverTest extends BaseTestCase { mapRequest = getDefaultMapRequestBuilder(); mapRequest.getEidRecord().add( - new EidRecordBuilder().setMask((short) 32).setLispAddressContainer(LispAFIConvertor.toContainer(v4Address)).build()); + new EidRecordBuilder().setMask((short) 32).setLispAddressContainer(v4Address).build()); mapRequest.getEidRecord().add( - new EidRecordBuilder().setMask((short) 128).setLispAddressContainer(LispAFIConvertor.toContainer(v6Address)).build()); + new EidRecordBuilder().setMask((short) 128).setLispAddressContainer(v6Address).build()); EidToLocatorRecordBuilder record1 = getDefaultEidToLocatorBuilder(); - record1.setLispAddressContainer(LispAFIConvertor.toContainer(v4Address)); + record1.setLispAddressContainer(v4Address); record1.setRecordTtl(100); LocatorRecordBuilder locator1 = getDefaultLocatorBuilder(); @@ -306,7 +300,7 @@ public class MapResolverTest extends BaseTestCase { record1.getLocatorRecord().add(locator1.build()); EidToLocatorRecordBuilder record2 = getDefaultEidToLocatorBuilder(); - record2.setLispAddressContainer(LispAFIConvertor.toContainer(v6Address)); + record2.setLispAddressContainer(v6Address); record2.setMaskLength((short) 128); record2.setRecordTtl(100); @@ -320,38 +314,33 @@ public class MapResolverTest extends BaseTestCase { EidToLocatorRecord eidToLocators1 = mapReply.getEidToLocatorRecord().get(0); assertEquals(1, eidToLocators1.getLocatorRecord().size()); - assertLocator(LispAFIConvertor.asIPAfiAddress("4.3.2.1"), eidToLocators1.getLocatorRecord().get(0)); + assertLocator(LispAFIConvertor.toContainer(LispAFIConvertor.asIPAfiAddress("4.3.2.1")), eidToLocators1 + .getLocatorRecord().get(0)); EidToLocatorRecord eidToLocators2 = mapReply.getEidToLocatorRecord().get(1); assertEquals(1, eidToLocators2.getLocatorRecord().size()); - assertLocator(LispAFIConvertor.asIPv6AfiAddress("0:0:0:0:0:0:0:1"), eidToLocators2.getLocatorRecord().get(0)); + assertLocator(LispAFIConvertor.toContainer(LispAFIConvertor.asIPv6AfiAddress("0:0:0:0:0:0:0:1")), eidToLocators2 + .getLocatorRecord().get(0)); } - private void assertLocator(LispAFIAddress expectedAddress, LocatorRecord locatorRecord) { - assertEquals(LispAFIConvertor.toContainer(expectedAddress), locatorRecord.getLispAddressContainer()); + private void assertLocator(LispAddressContainer expectedAddress, LocatorRecord locatorRecord) { + assertEquals(expectedAddress, locatorRecord.getLispAddressContainer()); Assert.assertTrue(locatorRecord.isRouted()); } - private Map prepareMapping(EidToLocatorRecord... records) { + private Map prepareMapping(EidToLocatorRecord... records) { if (records.length > 0) { for (EidToLocatorRecord eidToLocatorRecord : records) { - Map result = new HashMap(); - RLOCGroup rlocs = new RLOCGroup(eidToLocatorRecord.getRecordTtl(), eidToLocatorRecord.getAction(), - eidToLocatorRecord.isAuthoritative()); - for (LocatorRecord locator : eidToLocatorRecord.getLocatorRecord()) { - rlocs.addRecord(locator); - } - result.put(DAOSubKeys.ADDRESS_SUBKEY.toString(), rlocs); - - daoResults.put( - MappingKeyUtil.generateMappingKey(eidToLocatorRecord.getLispAddressContainer(), - (short) eidToLocatorRecord.getMaskLength()), result); + Map result = new HashMap(); + result.put(SubKeys.RECORD, eidToLocatorRecord); + + daoResults.put(eidToLocatorRecord.getLispAddressContainer(), result); } } - ValueSaverAction daoGetSaverAction = new ValueSaverAction() { + ValueSaverAction daoGetSaverAction = new ValueSaverAction() { @Override - protected boolean validate(IMappingKey value) { + protected boolean validate(LispAddressContainer value) { return true; } @@ -363,9 +352,9 @@ public class MapResolverTest extends BaseTestCase { allowing(lispDAO).get(with(daoGetSaverAction)); will(daoGetSaverAction); - allowing(lispDAO).getSpecific(wany(IMappingKey.class), with(DAOSubKeys.PASSWORD_SUBKEY.toString())); + allowing(lispDAO).getSpecific(wany(LispAddressContainer.class), with(SubKeys.PASSWORD)); - return daoResults.get(MappingKeyUtil.generateMappingKey(LispAFIConvertor.toContainer(v4Address))); + return daoResults.get(v4Address); } private MapRequestBuilder getDefaultMapRequestBuilder() { diff --git a/mappingservice/implementation/src/test/java/org/opendaylight/lispflowmapping/implementation/lisp/MapServerTest.java b/mappingservice/implementation/src/test/java/org/opendaylight/lispflowmapping/implementation/lisp/MapServerTest.java index 24c0f6376..8c3773713 100644 --- a/mappingservice/implementation/src/test/java/org/opendaylight/lispflowmapping/implementation/lisp/MapServerTest.java +++ b/mappingservice/implementation/src/test/java/org/opendaylight/lispflowmapping/implementation/lisp/MapServerTest.java @@ -18,13 +18,11 @@ import junitx.framework.ArrayAssert; import org.junit.Before; import org.junit.Test; import org.opendaylight.lispflowmapping.implementation.LispMappingService; -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.IMappingKey; import org.opendaylight.lispflowmapping.interfaces.dao.MappingEntry; -import org.opendaylight.lispflowmapping.interfaces.dao.RLOCGroup; +import org.opendaylight.lispflowmapping.interfaces.dao.SubKeys; import org.opendaylight.lispflowmapping.lisp.util.LispAFIConvertor; +import org.opendaylight.lispflowmapping.lisp.util.MaskUtil; import org.opendaylight.lispflowmapping.lisp.serializer.MapRegisterSerializer; import org.opendaylight.lispflowmapping.tools.junit.BaseTestCase; import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev150820.EidToLocatorRecord.Action; @@ -33,6 +31,7 @@ import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev150820.Ma import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev150820.MapRegister; import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev150820.eidtolocatorrecords.EidToLocatorRecord; import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev150820.eidtolocatorrecords.EidToLocatorRecordBuilder; +import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev150820.lispaddress.LispAddressContainer; import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev150820.lispaddress.lispaddresscontainer.address.no.NoAddressBuilder; import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev150820.locatorrecords.LocatorRecord; import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev150820.locatorrecords.LocatorRecordBuilder; @@ -43,10 +42,12 @@ public class MapServerTest extends BaseTestCase { private LispMappingService testedMapServer; private ILispDAO lispDAO; private MapRegisterBuilder mapRegisterBuilder; - private LispAFIAddress eid; - private LispAFIAddress rloc; + private LispAddressContainer eid; + private LispAddressContainer rloc; private ValueSaverAction[]> mappingEntriesSaver; private MapRegister mapRegisterWithAuthentication; + private String eidIpv4String = "10.31.0.5"; + private String eidIpv6String = "1:1:1:1:1:1:1:0"; @Override @Before @@ -58,12 +59,12 @@ public class MapServerTest extends BaseTestCase { mapRegisterBuilder = new MapRegisterBuilder(); mapRegisterBuilder.setKeyId((short) 0); mapRegisterBuilder.setAuthenticationData(new byte[0]); - eid = LispAFIConvertor.asIPAfiAddress("10.31.0.5"); - rloc = LispAFIConvertor.asIPAfiAddress("192.168.136.10"); + eid = LispAFIConvertor.asIPv4Address(eidIpv4String); + rloc = LispAFIConvertor.asIPv4Address("192.168.136.10"); EidToLocatorRecordBuilder recordBuilder = new EidToLocatorRecordBuilder(); - recordBuilder.setLispAddressContainer(LispAFIConvertor.toContainer(eid)).setMaskLength((short) 32); + recordBuilder.setLispAddressContainer(eid).setMaskLength((short) 32); recordBuilder.setLocatorRecord(new ArrayList()); - recordBuilder.getLocatorRecord().add(new LocatorRecordBuilder().setLispAddressContainer(LispAFIConvertor.toContainer(rloc)).build()); + recordBuilder.getLocatorRecord().add(new LocatorRecordBuilder().setLispAddressContainer(rloc).build()); recordBuilder.setAction(Action.NoAction).setMapVersion((short) 0).setAuthoritative(false).setRecordTtl(60).setMaskLength((short) 32); mapRegisterBuilder.setEidToLocatorRecord(new ArrayList()); mapRegisterBuilder.getEidToLocatorRecord().add(recordBuilder.build()); @@ -81,15 +82,14 @@ public class MapServerTest extends BaseTestCase { public void handleMapRegister__NonSetMBit() throws Exception { mapRegisterBuilder.setWantMapNotify(false); - addDefaultPutAndGetExpectations(eid, 32); + addDefaultPutAndGetExpectations(eid); assertNull(testedMapServer.handleMapRegister(mapRegisterBuilder.build(), false)); MappingEntry[] entries = mappingEntriesSaver.lastValue; assertEquals(1, entries.length); - - 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())); + assertEquals(SubKeys.RECORD, entries[0].getKey()); + assertEquals(rloc, ((EidToLocatorRecord) entries[0].getValue()) + .getLocatorRecord().get(0).getLispAddressContainer()); } @Test @@ -98,8 +98,8 @@ public class MapServerTest extends BaseTestCase { getDefaultEidToLocatorBuilder().setLispAddressContainer(LispAFIConvertor.toContainer(new NoAddressBuilder().build())).build()); mapRegisterBuilder.setWantMapNotify(true); - addDefaultPutAndGetExpectations(eid, 32); - addDefaultPutAndGetExpectations(new NoAddressBuilder().build(), 32); + addDefaultPutAndGetExpectations(eid); + addDefaultPutAndGetExpectations(LispAFIConvertor.toContainer(new NoAddressBuilder().build())); MapRegister mr = mapRegisterBuilder.build(); MapNotify mapNotify = testedMapServer.handleMapRegister(mr, false); assertEquals(mr.getEidToLocatorRecord(), mapNotify.getEidToLocatorRecord()); @@ -114,8 +114,8 @@ public class MapServerTest extends BaseTestCase { mapRegisterBuilder.setWantMapNotify(true); EidToLocatorRecordBuilder eidToLocatorBuilder = getDefaultEidToLocatorBuilder(); eidToLocatorBuilder.setMaskLength((short) 32); - eid = LispAFIConvertor.asIPAfiAddress("0.0.0.1"); - eidToLocatorBuilder.setLispAddressContainer(LispAFIConvertor.toContainer(eid)); + eid = LispAFIConvertor.asIPv4Address("0.0.0.1"); + eidToLocatorBuilder.setLispAddressContainer(eid); LocatorRecordBuilder locatorBuilder = getDefaultLocatorBuilder(); locatorBuilder.setLispAddressContainer(LispAFIConvertor.toContainer(LispAFIConvertor.asIPAfiAddress("0.0.0.2"))); @@ -124,12 +124,12 @@ public class MapServerTest extends BaseTestCase { mapRegisterBuilder.getEidToLocatorRecord().add(eidToLocatorBuilder.build()); - addDefaultPutAndGetExpectations(eid, 32); + addDefaultPutAndGetExpectations(eid); MapNotify mapNotify = testedMapServer.handleMapRegister(mapRegisterBuilder.build(), false); EidToLocatorRecord actualEidToLocator = mapNotify.getEidToLocatorRecord().get(0); - assertEquals(LispAFIConvertor.toContainer(eid), actualEidToLocator.getLispAddressContainer()); + assertEquals(eid, actualEidToLocator.getLispAddressContainer()); assertEquals((byte) 55, actualEidToLocator.getLocatorRecord().get(0).getPriority().byteValue()); } @@ -137,21 +137,21 @@ public class MapServerTest extends BaseTestCase { @Test public void handleMapRegisterIpv4__ValidMask() throws Exception { int mask = 16; + LispAddressContainer newEid = LispAFIConvertor.asIPv4Prefix(eidIpv4String, mask); mapRegisterBuilder = getDefaultMapRegisterBuilder(); EidToLocatorRecordBuilder recordBuilder = getDefaultEidToLocatorBuilder(); - recordBuilder.setLispAddressContainer(LispAFIConvertor.toContainer(eid)).setMaskLength((short) mask); + recordBuilder.setLispAddressContainer(newEid).setMaskLength((short) mask); LocatorRecordBuilder locator = getDefaultLocatorBuilder(); - locator.setLispAddressContainer(LispAFIConvertor.toContainer(rloc)); + locator.setLispAddressContainer(rloc); recordBuilder.getLocatorRecord().add(locator.build()); mapRegisterBuilder.getEidToLocatorRecord().add(recordBuilder.build()); mapRegisterBuilder.setWantMapNotify(true); MapRegister mr = mapRegisterBuilder.build(); - addDefaultPutAndGetExpectations(eid, mask); + addDefaultPutAndGetExpectations(newEid); MapNotify mapNotify = testedMapServer.handleMapRegister(mr, false); - assertEquals(LispAFIConvertor.toContainer(LispAFIConvertor.asIPAfiAddress("10.31.0.5")), mapNotify.getEidToLocatorRecord().get(0) - .getLispAddressContainer()); + assertEquals(newEid, mapNotify.getEidToLocatorRecord().get(0).getLispAddressContainer()); ArrayAssert.assertEquals(mr.getAuthenticationData(), mapNotify.getAuthenticationData()); assertEquals(mr.getEidToLocatorRecord(), mapNotify.getEidToLocatorRecord()); assertEquals(mr.getKeyId(), mapNotify.getKeyId()); @@ -162,21 +162,21 @@ public class MapServerTest extends BaseTestCase { public void handleMapRegister__NonMaskable() throws Exception { int mask = 16; mapRegisterBuilder = getDefaultMapRegisterBuilder(); - LispAFIAddress addr = LispAFIConvertor.asMacAfiAddress("01:01:01:01:01:01"); + LispAddressContainer addr = LispAFIConvertor.toContainer(LispAFIConvertor.asMacAfiAddress("01:01:01:01:01:01")); EidToLocatorRecordBuilder recordBuilder = getDefaultEidToLocatorBuilder(); LocatorRecordBuilder locatorBuilder = getDefaultLocatorBuilder(); - locatorBuilder.setLispAddressContainer(LispAFIConvertor.toContainer(rloc)); - recordBuilder.setLispAddressContainer(LispAFIConvertor.toContainer(addr)).setMaskLength((short) mask); + locatorBuilder.setLispAddressContainer(rloc); + recordBuilder.setLispAddressContainer(addr).setMaskLength((short) mask); recordBuilder.getLocatorRecord().add(locatorBuilder.build()); mapRegisterBuilder.getEidToLocatorRecord().add(recordBuilder.build()); mapRegisterBuilder.setWantMapNotify(true); - addDefaultPutAndGetExpectations(addr, mask); + addDefaultPutAndGetExpectations(addr); MapRegister mapRegister = mapRegisterBuilder.build(); MapNotify mapNotify = testedMapServer.handleMapRegister(mapRegister, false); - assertEquals(LispAFIConvertor.toContainer(addr), mapNotify.getEidToLocatorRecord().get(0).getLispAddressContainer()); + assertEquals(addr, mapNotify.getEidToLocatorRecord().get(0).getLispAddressContainer()); ArrayAssert.assertEquals(mapRegister.getAuthenticationData(), mapNotify.getAuthenticationData()); assertEquals(mapRegister.getEidToLocatorRecord(), mapNotify.getEidToLocatorRecord()); assertEquals(mapRegister.getKeyId(), mapNotify.getKeyId()); @@ -187,21 +187,21 @@ public class MapServerTest extends BaseTestCase { public void handleMapRegister__ZeroMask() throws Exception { int mask = 0; mapRegisterBuilder = getDefaultMapRegisterBuilder(); - LispAFIAddress addr = LispAFIConvertor.asMacAfiAddress("01:01:01:01:01:01"); + LispAddressContainer addr = LispAFIConvertor.toContainer(LispAFIConvertor.asMacAfiAddress("01:01:01:01:01:01")); EidToLocatorRecordBuilder recordBuilder = getDefaultEidToLocatorBuilder(); LocatorRecordBuilder locatorBuilder = getDefaultLocatorBuilder(); - locatorBuilder.setLispAddressContainer(LispAFIConvertor.toContainer(rloc)); - recordBuilder.setLispAddressContainer(LispAFIConvertor.toContainer(addr)).setMaskLength((short) mask); + locatorBuilder.setLispAddressContainer(rloc); + recordBuilder.setLispAddressContainer(addr).setMaskLength((short) mask); recordBuilder.getLocatorRecord().add(locatorBuilder.build()); mapRegisterBuilder.getEidToLocatorRecord().add(recordBuilder.build()); mapRegisterBuilder.setWantMapNotify(true); - addDefaultPutAndGetExpectations(addr, mask); + addDefaultPutAndGetExpectations(addr); MapRegister mapRegister = mapRegisterBuilder.build(); MapNotify mapNotify = testedMapServer.handleMapRegister(mapRegister, false); - assertEquals(LispAFIConvertor.toContainer(addr), mapNotify.getEidToLocatorRecord().get(0).getLispAddressContainer()); + assertEquals(addr, mapNotify.getEidToLocatorRecord().get(0).getLispAddressContainer()); ArrayAssert.assertEquals(mapRegister.getAuthenticationData(), mapNotify.getAuthenticationData()); assertEquals(mapRegister.getEidToLocatorRecord(), mapNotify.getEidToLocatorRecord()); assertEquals(mapRegister.getKeyId(), mapNotify.getKeyId()); @@ -211,21 +211,21 @@ public class MapServerTest extends BaseTestCase { @Test public void handleMapRegisterIPv4__ZeroMask() throws Exception { int mask = 0; + LispAddressContainer newEid = LispAFIConvertor.asIPv4Prefix(eidIpv4String, mask); mapRegisterBuilder = getDefaultMapRegisterBuilder(); EidToLocatorRecordBuilder recordBuilder = getDefaultEidToLocatorBuilder(); - recordBuilder.setLispAddressContainer(LispAFIConvertor.toContainer(eid)).setMaskLength((short) mask); + recordBuilder.setLispAddressContainer(newEid).setMaskLength((short) mask); LocatorRecordBuilder locator = getDefaultLocatorBuilder(); - locator.setLispAddressContainer(LispAFIConvertor.toContainer(rloc)); + locator.setLispAddressContainer(rloc); recordBuilder.getLocatorRecord().add(locator.build()); mapRegisterBuilder.getEidToLocatorRecord().add(recordBuilder.build()); mapRegisterBuilder.setWantMapNotify(true); MapRegister mr = mapRegisterBuilder.build(); - addDefaultPutAndGetExpectations(eid, mask); + addDefaultPutAndGetExpectations(newEid); MapNotify mapNotify = testedMapServer.handleMapRegister(mr, false); - assertEquals(LispAFIConvertor.toContainer(LispAFIConvertor.asIPAfiAddress("10.31.0.5")), mapNotify.getEidToLocatorRecord().get(0) - .getLispAddressContainer()); + assertEquals(newEid, mapNotify.getEidToLocatorRecord().get(0).getLispAddressContainer()); ArrayAssert.assertEquals(mr.getAuthenticationData(), mapNotify.getAuthenticationData()); assertEquals(mr.getEidToLocatorRecord(), mapNotify.getEidToLocatorRecord()); assertEquals(mr.getKeyId(), mapNotify.getKeyId()); @@ -237,19 +237,18 @@ public class MapServerTest extends BaseTestCase { int mask = 32; mapRegisterBuilder = getDefaultMapRegisterBuilder(); EidToLocatorRecordBuilder recordBuilder = getDefaultEidToLocatorBuilder(); - recordBuilder.setLispAddressContainer(LispAFIConvertor.toContainer(eid)).setMaskLength((short) mask); + recordBuilder.setLispAddressContainer(eid).setMaskLength((short) mask); LocatorRecordBuilder locator = getDefaultLocatorBuilder(); - locator.setLispAddressContainer(LispAFIConvertor.toContainer(rloc)); + locator.setLispAddressContainer(rloc); recordBuilder.getLocatorRecord().add(locator.build()); mapRegisterBuilder.getEidToLocatorRecord().add(recordBuilder.build()); mapRegisterBuilder.setWantMapNotify(true); MapRegister mr = mapRegisterBuilder.build(); - addDefaultPutAndGetExpectations(eid, mask); + addDefaultPutAndGetExpectations(eid); MapNotify mapNotify = testedMapServer.handleMapRegister(mr, false); - assertEquals(LispAFIConvertor.toContainer(LispAFIConvertor.asIPAfiAddress("10.31.0.5")), mapNotify.getEidToLocatorRecord().get(0) - .getLispAddressContainer()); + assertEquals(eid, mapNotify.getEidToLocatorRecord().get(0).getLispAddressContainer()); ArrayAssert.assertEquals(mr.getAuthenticationData(), mapNotify.getAuthenticationData()); assertEquals(mr.getEidToLocatorRecord(), mapNotify.getEidToLocatorRecord()); assertEquals(mr.getKeyId(), mapNotify.getKeyId()); @@ -260,21 +259,21 @@ public class MapServerTest extends BaseTestCase { public void handleMapRegisterIpv6__ValidMask96() throws Exception { int mask = 96; mapRegisterBuilder = getDefaultMapRegisterBuilder(); - LispAFIAddress addr = LispAFIConvertor.asIPv6AfiAddress("1:1:1:1:1:1:1:0"); + LispAddressContainer addr = LispAFIConvertor.asIPv6Prefix(eidIpv6String, mask); EidToLocatorRecordBuilder recordBuilder = getDefaultEidToLocatorBuilder(); LocatorRecordBuilder locatorBuilder = getDefaultLocatorBuilder(); - locatorBuilder.setLispAddressContainer(LispAFIConvertor.toContainer(rloc)); - recordBuilder.setLispAddressContainer(LispAFIConvertor.toContainer(addr)).setMaskLength((short) mask); + locatorBuilder.setLispAddressContainer(rloc); + recordBuilder.setLispAddressContainer(addr).setMaskLength((short) mask); recordBuilder.getLocatorRecord().add(locatorBuilder.build()); mapRegisterBuilder.getEidToLocatorRecord().add(recordBuilder.build()); mapRegisterBuilder.setWantMapNotify(true); - addDefaultPutAndGetExpectations(addr, mask); + addDefaultPutAndGetExpectations(addr); MapRegister mapRegister = mapRegisterBuilder.build(); MapNotify mapNotify = testedMapServer.handleMapRegister(mapRegister, false); - assertEquals(LispAFIConvertor.toContainer(addr), mapNotify.getEidToLocatorRecord().get(0).getLispAddressContainer()); + assertEquals(addr, mapNotify.getEidToLocatorRecord().get(0).getLispAddressContainer()); ArrayAssert.assertEquals(mapRegister.getAuthenticationData(), mapNotify.getAuthenticationData()); assertEquals(mapRegister.getEidToLocatorRecord(), mapNotify.getEidToLocatorRecord()); assertEquals(mapRegister.getKeyId(), mapNotify.getKeyId()); @@ -285,21 +284,21 @@ public class MapServerTest extends BaseTestCase { public void handleMapRegisterIpv6__ZeroMask() throws Exception { int mask = 0; mapRegisterBuilder = getDefaultMapRegisterBuilder(); - LispAFIAddress addr = LispAFIConvertor.asIPv6AfiAddress("1:1:1:1:1:1:1:0"); + LispAddressContainer addr = LispAFIConvertor.asIPv6Prefix(eidIpv6String, mask); EidToLocatorRecordBuilder recordBuilder = getDefaultEidToLocatorBuilder(); LocatorRecordBuilder locatorBuilder = getDefaultLocatorBuilder(); - locatorBuilder.setLispAddressContainer(LispAFIConvertor.toContainer(rloc)); - recordBuilder.setLispAddressContainer(LispAFIConvertor.toContainer(addr)).setMaskLength((short) mask); + locatorBuilder.setLispAddressContainer(rloc); + recordBuilder.setLispAddressContainer(addr).setMaskLength((short) mask); recordBuilder.getLocatorRecord().add(locatorBuilder.build()); mapRegisterBuilder.getEidToLocatorRecord().add(recordBuilder.build()); mapRegisterBuilder.setWantMapNotify(true); - addDefaultPutAndGetExpectations(addr, mask); + addDefaultPutAndGetExpectations(addr); MapRegister mapRegister = mapRegisterBuilder.build(); MapNotify mapNotify = testedMapServer.handleMapRegister(mapRegister, false); - assertEquals(LispAFIConvertor.toContainer(addr), mapNotify.getEidToLocatorRecord().get(0).getLispAddressContainer()); + assertEquals(addr, mapNotify.getEidToLocatorRecord().get(0).getLispAddressContainer()); ArrayAssert.assertEquals(mapRegister.getAuthenticationData(), mapNotify.getAuthenticationData()); assertEquals(mapRegister.getEidToLocatorRecord(), mapNotify.getEidToLocatorRecord()); assertEquals(mapRegister.getKeyId(), mapNotify.getKeyId()); @@ -310,21 +309,21 @@ public class MapServerTest extends BaseTestCase { public void handleMapRegisterIpv6__ValidMask48() throws Exception { int mask = 48; mapRegisterBuilder = getDefaultMapRegisterBuilder(); - LispAFIAddress addr = LispAFIConvertor.asIPv6AfiAddress("1:1:1:1:1:1:1:0"); + LispAddressContainer addr = LispAFIConvertor.asIPv6Prefix(eidIpv6String, mask); EidToLocatorRecordBuilder recordBuilder = getDefaultEidToLocatorBuilder(); LocatorRecordBuilder locatorBuilder = getDefaultLocatorBuilder(); - locatorBuilder.setLispAddressContainer(LispAFIConvertor.toContainer(rloc)); - recordBuilder.setLispAddressContainer(LispAFIConvertor.toContainer(addr)).setMaskLength((short) mask); + locatorBuilder.setLispAddressContainer(rloc); + recordBuilder.setLispAddressContainer(addr).setMaskLength((short) mask); recordBuilder.getLocatorRecord().add(locatorBuilder.build()); mapRegisterBuilder.getEidToLocatorRecord().add(recordBuilder.build()); mapRegisterBuilder.setWantMapNotify(true); - addDefaultPutAndGetExpectations(addr, mask); + addDefaultPutAndGetExpectations(addr); MapRegister mapRegister = mapRegisterBuilder.build(); MapNotify mapNotify = testedMapServer.handleMapRegister(mapRegister, false); - assertEquals(LispAFIConvertor.toContainer(addr), mapNotify.getEidToLocatorRecord().get(0).getLispAddressContainer()); + assertEquals(addr, mapNotify.getEidToLocatorRecord().get(0).getLispAddressContainer()); ArrayAssert.assertEquals(mapRegister.getAuthenticationData(), mapNotify.getAuthenticationData()); assertEquals(mapRegister.getEidToLocatorRecord(), mapNotify.getEidToLocatorRecord()); assertEquals(mapRegister.getKeyId(), mapNotify.getKeyId()); @@ -335,21 +334,21 @@ public class MapServerTest extends BaseTestCase { public void handleMapRegisterIpv6__ValidMask128() throws Exception { int mask = 128; mapRegisterBuilder = getDefaultMapRegisterBuilder(); - LispAFIAddress addr = LispAFIConvertor.asIPv6AfiAddress("1:1:1:1:1:1:1:0"); + LispAddressContainer addr = LispAFIConvertor.asIPv6Address(eidIpv6String); EidToLocatorRecordBuilder recordBuilder = getDefaultEidToLocatorBuilder(); LocatorRecordBuilder locatorBuilder = getDefaultLocatorBuilder(); - locatorBuilder.setLispAddressContainer(LispAFIConvertor.toContainer(rloc)); - recordBuilder.setLispAddressContainer(LispAFIConvertor.toContainer(addr)).setMaskLength((short) mask); + locatorBuilder.setLispAddressContainer(rloc); + recordBuilder.setLispAddressContainer(addr).setMaskLength((short) mask); recordBuilder.getLocatorRecord().add(locatorBuilder.build()); mapRegisterBuilder.getEidToLocatorRecord().add(recordBuilder.build()); mapRegisterBuilder.setWantMapNotify(true); - addDefaultPutAndGetExpectations(addr, mask); + addDefaultPutAndGetExpectations(addr); MapRegister mapRegister = mapRegisterBuilder.build(); MapNotify mapNotify = testedMapServer.handleMapRegister(mapRegister, false); - assertEquals(LispAFIConvertor.toContainer(addr), mapNotify.getEidToLocatorRecord().get(0).getLispAddressContainer()); + assertEquals(addr, mapNotify.getEidToLocatorRecord().get(0).getLispAddressContainer()); ArrayAssert.assertEquals(mapRegister.getAuthenticationData(), mapNotify.getAuthenticationData()); assertEquals(mapRegister.getEidToLocatorRecord(), mapNotify.getEidToLocatorRecord()); assertEquals(mapRegister.getKeyId(), mapNotify.getKeyId()); @@ -361,26 +360,26 @@ public class MapServerTest extends BaseTestCase { int mask = 96; mapRegisterBuilder = getDefaultMapRegisterBuilder(); EidToLocatorRecordBuilder recordBuilder0 = getDefaultEidToLocatorBuilder(); - recordBuilder0.setLispAddressContainer(LispAFIConvertor.toContainer(eid)).setMaskLength((short) 32); - LispAFIAddress addr = LispAFIConvertor.asIPv6AfiAddress("1:1:1:1:1:1:1:0"); + recordBuilder0.setLispAddressContainer(eid).setMaskLength((short) 32); + LispAddressContainer addr = LispAFIConvertor.asIPv6Prefix(eidIpv6String, mask); EidToLocatorRecordBuilder recordBuilder1 = getDefaultEidToLocatorBuilder(); LocatorRecordBuilder locatorBuilder = getDefaultLocatorBuilder(); - locatorBuilder.setLispAddressContainer(LispAFIConvertor.toContainer(rloc)); - locatorBuilder.setLispAddressContainer(LispAFIConvertor.toContainer(rloc)); - recordBuilder1.setLispAddressContainer(LispAFIConvertor.toContainer(addr)).setMaskLength((short) mask); + locatorBuilder.setLispAddressContainer(rloc); + locatorBuilder.setLispAddressContainer(rloc); + recordBuilder1.setLispAddressContainer(addr).setMaskLength((short) mask); recordBuilder1.getLocatorRecord().add(locatorBuilder.build()); mapRegisterBuilder.getEidToLocatorRecord().add(recordBuilder0.build()); mapRegisterBuilder.getEidToLocatorRecord().add(recordBuilder1.build()); mapRegisterBuilder.setWantMapNotify(true); - addDefaultPutAndGetExpectations(eid, 32); - addDefaultPutAndGetExpectations(addr, mask); + addDefaultPutAndGetExpectations(eid); + addDefaultPutAndGetExpectations(addr); MapRegister mapRegister = mapRegisterBuilder.build(); MapNotify mapNotify = testedMapServer.handleMapRegister(mapRegister, false); - assertEquals(LispAFIConvertor.toContainer(eid), mapNotify.getEidToLocatorRecord().get(0).getLispAddressContainer()); - assertEquals(LispAFIConvertor.toContainer(addr), mapNotify.getEidToLocatorRecord().get(1).getLispAddressContainer()); + assertEquals(eid, mapNotify.getEidToLocatorRecord().get(0).getLispAddressContainer()); + assertEquals(addr, mapNotify.getEidToLocatorRecord().get(1).getLispAddressContainer()); ArrayAssert.assertEquals(mapRegister.getAuthenticationData(), mapNotify.getAuthenticationData()); assertEquals(mapRegister.getEidToLocatorRecord(), mapNotify.getEidToLocatorRecord()); assertEquals(mapRegister.getKeyId(), mapNotify.getKeyId()); @@ -389,17 +388,17 @@ public class MapServerTest extends BaseTestCase { @Test public void handleMapRegister__MultipleRLOCs() throws Exception { - addDefaultPutAndGetExpectations(eid, 32); + addDefaultPutAndGetExpectations(eid); mapRegisterBuilder = getDefaultMapRegisterBuilder(); - LispAFIAddress rloc0 = rloc; - LispAFIAddress rloc1 = LispAFIConvertor.asIPv6AfiAddress("0:0:0:0:0:0:0:7"); + LispAddressContainer rloc0 = rloc; + LispAddressContainer rloc1 = LispAFIConvertor.asIPv6Address("0:0:0:0:0:0:0:7"); EidToLocatorRecordBuilder recordBuilder = getDefaultEidToLocatorBuilder(); - recordBuilder.setLispAddressContainer(LispAFIConvertor.toContainer(eid)); + recordBuilder.setLispAddressContainer(eid); LocatorRecordBuilder locatorBuilder1 = getDefaultLocatorBuilder(); - locatorBuilder1.setLispAddressContainer(LispAFIConvertor.toContainer(rloc0)); + locatorBuilder1.setLispAddressContainer(rloc0); LocatorRecordBuilder locatorBuilder2 = getDefaultLocatorBuilder(); - locatorBuilder2.setLispAddressContainer(LispAFIConvertor.toContainer(rloc1)); + locatorBuilder2.setLispAddressContainer(rloc1); recordBuilder.getLocatorRecord().add(locatorBuilder1.build()); recordBuilder.getLocatorRecord().add(locatorBuilder2.build()); @@ -410,29 +409,29 @@ public class MapServerTest extends BaseTestCase { MappingEntry[] entries = mappingEntriesSaver.lastValue; assertEquals(1, entries.length); - assertEquals(DAOSubKeys.ADDRESS_SUBKEY.toString(), entries[0].getKey()); - assertEquals(LispAFIConvertor.toContainer(rloc0), ((RLOCGroup) entries[0].getValue()).getRecords().get(0) - .getLispAddressContainer()); - assertEquals(LispAFIConvertor.toContainer(rloc1), ((RLOCGroup) entries[0].getValue()).getRecords().get(1) - .getLispAddressContainer()); + assertEquals(SubKeys.RECORD, entries[0].getKey()); + assertEquals(rloc0, ((EidToLocatorRecord) entries[0].getValue()).getLocatorRecord() + .get(0).getLispAddressContainer()); + assertEquals(rloc1, ((EidToLocatorRecord) entries[0].getValue()).getLocatorRecord() + .get(1).getLispAddressContainer()); } @Test public void handleMapRegister__MultipleTypes() throws Exception { - addDefaultPutAndGetExpectations(eid, 32); + addDefaultPutAndGetExpectations(eid); mapRegisterBuilder = getDefaultMapRegisterBuilder(); - LispAFIAddress rloc0 = rloc; + LispAddressContainer rloc0 = rloc; // LispAFIAddress rloc1 = // LispAFIConvertor.asIPv6AfiAddress("0:0:0:0:0:0:0:7"); String subkey = "bla"; LispAFIAddress rloc1 = LispAFIConvertor .asKeyValue(subkey, LispAFIConvertor.toPrimitive(LispAFIConvertor.asIPv6AfiAddress("0:0:0:0:0:0:0:7"))); EidToLocatorRecordBuilder recordBuilder = getDefaultEidToLocatorBuilder(); - recordBuilder.setLispAddressContainer(LispAFIConvertor.toContainer(eid)); + recordBuilder.setLispAddressContainer(eid); LocatorRecordBuilder locatorBuilder1 = getDefaultLocatorBuilder(); - locatorBuilder1.setLispAddressContainer(LispAFIConvertor.toContainer(rloc0)); + locatorBuilder1.setLispAddressContainer(rloc0); LocatorRecordBuilder locatorBuilder2 = getDefaultLocatorBuilder(); locatorBuilder2.setLispAddressContainer(LispAFIConvertor.toContainer(rloc1)); recordBuilder.getLocatorRecord().add(locatorBuilder1.build()); @@ -443,53 +442,52 @@ public class MapServerTest extends BaseTestCase { testedMapServer.handleMapRegister(mapRegisterBuilder.build(), false); MappingEntry[] entries = mappingEntriesSaver.lastValue; - assertEquals(2, entries.length); - - assertEquals(DAOSubKeys.ADDRESS_SUBKEY.toString(), entries[0].getKey()); - assertEquals(subkey, entries[1].getKey()); - assertEquals(LispAFIConvertor.toContainer(rloc0), ((RLOCGroup) entries[0].getValue()).getRecords().get(0) - .getLispAddressContainer()); - assertEquals(LispAFIConvertor.toContainer(rloc1), ((RLOCGroup) entries[1].getValue()).getRecords().get(0) + assertEquals(1, entries.length); + EidToLocatorRecord storedMapping = (EidToLocatorRecord) entries[0].getValue(); + assertEquals(2, storedMapping.getLocatorRecord().size()); + assertEquals(SubKeys.RECORD, entries[0].getKey()); + assertEquals(rloc0, storedMapping.getLocatorRecord().get(0).getLispAddressContainer()); + assertEquals(LispAFIConvertor.toContainer(rloc1), storedMapping.getLocatorRecord().get(1) .getLispAddressContainer()); } @Test public void handleMapRegister__TestOverwrite() throws Exception { - addDefaultPutAndGetExpectations(eid, 32); + addDefaultPutAndGetExpectations(eid); addEidToLocatorRecord(); MappingEntry[] entries = mappingEntriesSaver.lastValue; assertEquals(1, entries.length); - assertEquals(DAOSubKeys.ADDRESS_SUBKEY.toString(), entries[0].getKey()); - assertEquals(LispAFIConvertor.toContainer(rloc), ((RLOCGroup) entries[0].getValue()).getRecords().get(0) - .getLispAddressContainer()); - } - - @Test - public void handleMapRegister__TestDontOverwrite() throws Exception { - int hc = LispAFIConvertor.toContainer(rloc).getAddress().hashCode(); - - addDefaultPutAndGetExpectations(eid, 32); - testedMapServer.setOverwrite(false); - - addEidToLocatorRecord(); - - MappingEntry[] entries = mappingEntriesSaver.lastValue; - assertEquals(1, entries.length); - - assertEquals(String.valueOf(hc), entries[0].getKey()); - assertEquals(LispAFIConvertor.toContainer(rloc), ((RLOCGroup) entries[0].getValue()).getRecords().get(0) - .getLispAddressContainer()); - } + assertEquals(SubKeys.RECORD, entries[0].getKey()); + assertEquals(rloc, ((EidToLocatorRecord) entries[0].getValue()).getLocatorRecord() + .get(0).getLispAddressContainer()); + } + +// @Test +// public void handleMapRegister__TestDontOverwrite() throws Exception { +// int hc = rloc.getAddress().hashCode(); +// +// addDefaultPutAndGetExpectations(eid); +// testedMapServer.setOverwrite(false); +// +// addEidToLocatorRecord(); +// +// MappingEntry[] entries = mappingEntriesSaver.lastValue; +// assertEquals(1, entries.length); +// +// assertEquals(String.valueOf(hc), entries[0].getKey()); +// assertEquals(rloc, ((EidToLocatorRecord) entries[0].getValue()).getLocatorRecord() +// .get(0).getLispAddressContainer()); +// } private void addEidToLocatorRecord() { EidToLocatorRecordBuilder recordBuilder = getDefaultEidToLocatorBuilder(); - recordBuilder.setLispAddressContainer(LispAFIConvertor.toContainer(eid)); + recordBuilder.setLispAddressContainer(eid); LocatorRecordBuilder locatorBuilder = getDefaultLocatorBuilder(); - locatorBuilder.setLispAddressContainer(LispAFIConvertor.toContainer(rloc)); + locatorBuilder.setLispAddressContainer(rloc); recordBuilder.getLocatorRecord().add(locatorBuilder.build()); mapRegisterBuilder = getDefaultMapRegisterBuilder(); @@ -500,18 +498,18 @@ public class MapServerTest extends BaseTestCase { @Test public void handleMapRegister__MultipleEIDs() throws Exception { - addDefaultPutAndGetExpectations(eid, 32); + addDefaultPutAndGetExpectations(eid); - LispAFIAddress rloc1 = LispAFIConvertor.asIPv6AfiAddress("0:0:0:0:0:0:0:7"); + LispAddressContainer rloc1 = LispAFIConvertor.asIPv6Address("0:0:0:0:0:0:0:7"); mapRegisterBuilder = getDefaultMapRegisterBuilder(); EidToLocatorRecordBuilder etlrBuilder = getDefaultEidToLocatorBuilder(); - etlrBuilder.getLocatorRecord().add(getDefaultLocatorBuilder().setLispAddressContainer(LispAFIConvertor.toContainer(rloc1)).build()); + etlrBuilder.getLocatorRecord().add(getDefaultLocatorBuilder().setLispAddressContainer(rloc1).build()); mapRegisterBuilder.setWantMapNotify(true); - etlrBuilder.setLispAddressContainer(LispAFIConvertor.toContainer(eid)); + etlrBuilder.setLispAddressContainer(eid); EidToLocatorRecordBuilder etlr2Builder = getDefaultEidToLocatorBuilder(); - LispAFIAddress address = LispAFIConvertor.asIPAfiAddress("1.1.1.1"); - etlr2Builder.setLispAddressContainer(LispAFIConvertor.toContainer(address)); + LispAddressContainer address = LispAFIConvertor.asIPv4Address("1.1.1.1"); + etlr2Builder.setLispAddressContainer(address); etlr2Builder.setMaskLength((short) 32); int recordTtl = 5; etlr2Builder.setRecordTtl(recordTtl); @@ -520,15 +518,14 @@ public class MapServerTest extends BaseTestCase { .setLispAddressContainer(LispAFIConvertor.toContainer(LispAFIConvertor.asIPAfiAddress("2.2.2.2"))).build()); mapRegisterBuilder.getEidToLocatorRecord().add(etlrBuilder.build()); mapRegisterBuilder.getEidToLocatorRecord().add(etlr2Builder.build()); - addDefaultPutAndGetExpectations(address, 32); + addDefaultPutAndGetExpectations(address); MapNotify mapNotify = testedMapServer.handleMapRegister(mapRegisterBuilder.build(), false); - assertEquals(LispAFIConvertor.toContainer(rloc1), mapNotify.getEidToLocatorRecord().get(0).getLocatorRecord().get(0) + assertEquals(rloc1, mapNotify.getEidToLocatorRecord().get(0).getLocatorRecord().get(0) .getLispAddressContainer()); assertEquals(LispAFIConvertor.toContainer(LispAFIConvertor.asIPAfiAddress("2.2.2.2")), mapNotify.getEidToLocatorRecord().get(1) .getLocatorRecord().get(0).getLispAddressContainer()); - assertEquals(LispAFIConvertor.toContainer(LispAFIConvertor.asIPAfiAddress("1.1.1.1")), mapNotify.getEidToLocatorRecord().get(1) - .getLispAddressContainer()); + assertEquals(address, mapNotify.getEidToLocatorRecord().get(1).getLispAddressContainer()); assertEquals(recordTtl, mapNotify.getEidToLocatorRecord().get(1).getRecordTtl().intValue()); } @@ -536,7 +533,7 @@ public class MapServerTest extends BaseTestCase { @Test public void handleMapRegisterIpv4__ChekWrongPassword() throws Exception { - addGetExpectations(LispAFIConvertor.asIPAfiAddress("153.16.254.1"), 32, 0, 31, "bla"); + addGetExpectations(LispAFIConvertor.asIPv4Address("153.16.254.1"), 0, 31, "bla"); MapNotify mapNotify = testedMapServer.handleMapRegister(mapRegisterWithAuthentication, false); assertEquals(null, mapNotify); } @@ -544,8 +541,8 @@ public class MapServerTest extends BaseTestCase { @Test public void handleMapRegisterIpv4__ChcekNoPasswordAndThenPassword() throws Exception { - addGetExpectations(LispAFIConvertor.asIPAfiAddress("153.16.254.1"), 32, 30, 25, "password"); - addPutExpectations(LispAFIConvertor.asIPAfiAddress("153.16.254.1"), 32); + addGetExpectations(LispAFIConvertor.asIPv4Address("153.16.254.1"), 0, 25, "password"); + addPutExpectations(LispAFIConvertor.asIPv4Address("153.16.254.1")); MapNotify mapNotify = testedMapServer.handleMapRegister(mapRegisterWithAuthentication, false); assertEquals(mapRegisterWithAuthentication.getEidToLocatorRecord(), mapNotify.getEidToLocatorRecord()); assertEquals(mapRegisterWithAuthentication.getKeyId(), mapNotify.getKeyId()); @@ -555,7 +552,7 @@ public class MapServerTest extends BaseTestCase { @Test public void handleMapRegisterIpv4__ChcekNoPassword() throws Exception { - addGetExpectations(LispAFIConvertor.asIPAfiAddress("153.16.254.1"), 32, 30, 0, "password"); + addGetExpectations(LispAFIConvertor.asIPv4Address("153.16.254.1"), 30, 0, "password"); MapNotify mapNotify = testedMapServer.handleMapRegister(mapRegisterWithAuthentication, false); assertEquals(null, mapNotify); } @@ -563,7 +560,7 @@ public class MapServerTest extends BaseTestCase { @Test public void handleMapRegisterIpv4__ChcekNoreturn() throws Exception { - addGetExpectations(LispAFIConvertor.asIPAfiAddress("153.16.254.1"), 32); + addGetExpectations(LispAFIConvertor.asIPv4Address("153.16.254.1")); MapNotify mapNotify = testedMapServer.handleMapRegister(mapRegisterWithAuthentication, false); assertEquals(mapNotify, null); } @@ -572,81 +569,76 @@ public class MapServerTest extends BaseTestCase { @Test public void handleAddAuthenticationKey() throws Exception { String password = "pass"; - IMappingKey key = getDefualtKey(); + LispAddressContainer key = getDefaultKey(); oneOf(lispDAO).put(weq(key), - weq((MappingEntry[]) (Arrays.asList(new MappingEntry(DAOSubKeys.PASSWORD_SUBKEY.toString(), password)).toArray()))); - testedMapServer.addAuthenticationKey(LispAFIConvertor.toContainer(eid), key.getMask(), password); + weq((MappingEntry[]) (Arrays.asList(new MappingEntry(SubKeys.PASSWORD, password)).toArray()))); + testedMapServer.addAuthenticationKey(eid, password); } @Test public void handleGetAuthenticationKey() throws Exception { - IMappingKey key = getDefualtKey(); - oneOf(lispDAO).getSpecific(weq(key), with(DAOSubKeys.PASSWORD_SUBKEY.toString())); + LispAddressContainer key = getDefaultKey(); + oneOf(lispDAO).getSpecific(weq(key), with(SubKeys.PASSWORD)); ret("password"); - assertEquals("password", testedMapServer.getAuthenticationKey(LispAFIConvertor.toContainer(eid), key.getMask())); + assertEquals("password", testedMapServer.getAuthenticationKey(eid)); } @Test public void handleGetAuthenticationKeyNoIteration() throws Exception { testedMapServer.setShouldIterateMask(false); - 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())); + LispAddressContainer key = getDefaultKey(); + LispAddressContainer passKey = getKey(30); + oneOf(lispDAO).getSpecific(weq(key), with(SubKeys.PASSWORD)); + allowing(lispDAO).getSpecific(weq(passKey), with(SubKeys.PASSWORD)); ret("password"); - assertEquals(null, testedMapServer.getAuthenticationKey(LispAFIConvertor.toContainer(eid), key.getMask())); + assertEquals(null, testedMapServer.getAuthenticationKey(eid)); } @Test public void handleRemoveAuthenticationKey() throws Exception { - IMappingKey key = getDefualtKey(); - oneOf(lispDAO).removeSpecific(weq(key), with(DAOSubKeys.PASSWORD_SUBKEY.toString())); - testedMapServer.removeAuthenticationKey(LispAFIConvertor.toContainer(eid), key.getMask()); + LispAddressContainer key = getDefaultKey(); + oneOf(lispDAO).removeSpecific(weq(key), with(SubKeys.PASSWORD)); + testedMapServer.removeAuthenticationKey(eid); } - private void addDefaultPutAndGetExpectations(LispAFIAddress addr, int mask) { - addPutExpectations(addr, mask); - addGetExpectations(addr, mask); + private void addDefaultPutAndGetExpectations(LispAddressContainer addr) { + addPutExpectations(addr); + addGetExpectations(addr); } - private void addGetExpectations(LispAFIAddress address, int mask) { - addGetExpectations(address, mask, 0, 0, "password"); + private void addGetExpectations(LispAddressContainer address) { + addGetExpectations(address, 0, 0, SubKeys.PASSWORD); } - private void addPutExpectations(LispAFIAddress address, int mask) { - oneOf(lispDAO).put(weq(MappingKeyUtil.generateMappingKey(LispAFIConvertor.toContainer(address), mask)), - with(mappingEntriesSaver)); + private void addPutExpectations(LispAddressContainer address) { + exactly(2).of(lispDAO).put(weq(address), with(mappingEntriesSaver)); } - private void addGetExpectations(LispAFIAddress address, int mask, int withoutPassword, int withPassword, String password) { + private void addGetExpectations(LispAddressContainer address, int withoutPassword, int withPassword, String password) { if (withoutPassword > 0) { String result = null; result = null; - allowing(lispDAO).getSpecific( - with(MappingKeyUtil.generateMappingKey(LispAFIConvertor.toContainer(address), withoutPassword)), with("password")); + allowing(lispDAO).getSpecific(with(address), with(SubKeys.PASSWORD)); ret(result); } if (withPassword > 0) { String result = null; result = password; - allowing(lispDAO).getSpecific(with(MappingKeyUtil.generateMappingKey(LispAFIConvertor.toContainer(address), withPassword)), - with("password")); + allowing(lispDAO).getSpecific(with(address), with(SubKeys.PASSWORD)); ret(result); } - for (int i = mask; i >= 0; i--) { - allowing(lispDAO).getSpecific(with(MappingKeyUtil.generateMappingKey(LispAFIConvertor.toContainer(address), i)), - with("password")); + for (int i = MaskUtil.getMaskForAddress(address); i >= 0; i--) { + allowing(lispDAO).getSpecific(with(MaskUtil.normalize(address, (short) i)), with(SubKeys.PASSWORD)); ret(null); } } - private IMappingKey getDefualtKey() { + private LispAddressContainer getDefaultKey() { return getKey(32); } - private IMappingKey getKey(int mask) { - IMappingKey key = MappingKeyUtil.generateMappingKey(LispAFIConvertor.toContainer(eid), mask); - return key; + private LispAddressContainer getKey(int mask) { + return MaskUtil.normalize(eid, (short)mask); } private MapRegisterBuilder getDefaultMapRegisterBuilder() { diff --git a/mappingservice/inmemorydb/src/main/java/org/opendaylight/lispflowmapping/inmemorydb/HashMapDb.java b/mappingservice/inmemorydb/src/main/java/org/opendaylight/lispflowmapping/inmemorydb/HashMapDb.java index 1fa6b2ce4..73b520869 100644 --- a/mappingservice/inmemorydb/src/main/java/org/opendaylight/lispflowmapping/inmemorydb/HashMapDb.java +++ b/mappingservice/inmemorydb/src/main/java/org/opendaylight/lispflowmapping/inmemorydb/HashMapDb.java @@ -8,6 +8,7 @@ package org.opendaylight.lispflowmapping.inmemorydb; +import java.util.Date; import java.util.Map; import java.util.concurrent.ConcurrentHashMap; import java.util.concurrent.ConcurrentMap; @@ -16,7 +17,7 @@ import java.util.concurrent.TimeUnit; 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.RLOCGroup; +import org.opendaylight.lispflowmapping.interfaces.dao.SubKeys; import org.slf4j.Logger; import org.slf4j.LoggerFactory; @@ -77,19 +78,20 @@ public class HashMapDb implements ILispDAO, AutoCloseable { data.clear(); } + // TODO: this should be moved outside of DAO implementation public void cleanOld() { getAll(new IRowVisitor() { public void visitRow(Object keyId, String valueKey, Object value) { - if (value instanceof RLOCGroup) { - RLOCGroup rloc = (RLOCGroup) value; - if (isExpired(rloc)) { - removeSpecific(keyId, valueKey); + if (value != null && valueKey instanceof String && ((String) valueKey).equals(SubKeys.REGDATE)) { + Date date = (Date) value; + if (isExpired(date)) { + removeSpecific(keyId, SubKeys.RECORD); } } } - private boolean isExpired(RLOCGroup rloc) { - return System.currentTimeMillis() - rloc.getRegisterdDate().getTime() > TimeUnit.MILLISECONDS.convert(recordTimeOut, timeUnit); + private boolean isExpired(Date date) { + return System.currentTimeMillis() - date.getTime() > TimeUnit.MILLISECONDS.convert(recordTimeOut, timeUnit); } }); } @@ -114,4 +116,15 @@ public class HashMapDb implements ILispDAO, AutoCloseable { data.clear(); } + @Override + public ILispDAO putNestedTable(Object key, String valueKey) { + ILispDAO nestedTable = (ILispDAO) getSpecific(key, valueKey); + if (nestedTable != null) { + LOG.warn("Trying to add nested table that already exists. Aborting!"); + return nestedTable; + } + nestedTable = new HashMapDb(); + put(key, new MappingEntry<>(valueKey, nestedTable)); + return nestedTable; + } } diff --git a/mappingservice/integrationtest/src/test/java/org/opendaylight/lispflowmapping/integrationtest/MappingServiceIntegrationTest.java b/mappingservice/integrationtest/src/test/java/org/opendaylight/lispflowmapping/integrationtest/MappingServiceIntegrationTest.java index 0d0ccf342..53504bac3 100644 --- a/mappingservice/integrationtest/src/test/java/org/opendaylight/lispflowmapping/integrationtest/MappingServiceIntegrationTest.java +++ b/mappingservice/integrationtest/src/test/java/org/opendaylight/lispflowmapping/integrationtest/MappingServiceIntegrationTest.java @@ -88,8 +88,10 @@ import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev150820.lc import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev150820.lcaftrafficengineeringaddress.Hops; import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev150820.lcaftrafficengineeringaddress.HopsBuilder; import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev150820.lispaddress.LispAddressContainer; +import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev150820.lispaddress.LispAddressContainerBuilder; import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev150820.lispaddress.lispaddresscontainer.address.LcafKeyValue; import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev150820.lispaddress.lispaddresscontainer.address.LcafSourceDest; +import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev150820.lispaddress.lispaddresscontainer.address.LcafSourceDestBuilder; import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev150820.lispaddress.lispaddresscontainer.address.ipv4.Ipv4Address; import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev150820.lispaddress.lispaddresscontainer.address.lcafapplicationdata.LcafApplicationDataAddr; import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev150820.lispaddress.lispaddresscontainer.address.lcafapplicationdata.LcafApplicationDataAddrBuilder; @@ -353,9 +355,11 @@ public class MappingServiceIntegrationTest extends AbstractMdsalTestBase { @Test public void testOverWriting() throws Exception { //testMapRegisterDosntOverwritesOtherSubKeys(); TODO weird failure, needs debug - testMapRegisterOverwritesSameSubkey(); - testMapRegisterOverwritesNoSubkey(); - testMapRegisterDoesntOverwritesNoSubkey(); + + // TODO: remove, we don't support overwrite flag any longer and RLOCs are not saved as independent RLOC groups + // testMapRegisterOverwritesSameSubkey(); + // testMapRegisterOverwritesNoSubkey(); + // testMapRegisterDoesntOverwritesNoSubkey(); } @Test @@ -404,7 +408,7 @@ public class MappingServiceIntegrationTest extends AbstractMdsalTestBase { public void mapRegisterWithMapNotifyAndMapRequest() throws SocketTimeoutException { cleanUP(); - LispAFIAddress eid = LispAFIConvertor.asIPAfiAddress("1.2.3.4"); + LispAFIAddress eid = LispAFIConvertor.toAFI(LispAFIConvertor.asIPv4Address("1.2.3.4")); MapReply mapReply = registerAddressAndQuery(eid, 32); @@ -430,7 +434,7 @@ public class MappingServiceIntegrationTest extends AbstractMdsalTestBase { public void mapRequestMapRegisterAndMapRequest() throws SocketTimeoutException { cleanUP(); - LispAFIAddress eid = LispAFIConvertor.asIPAfiAddress("1.2.3.4"); + LispAFIAddress eid = LispAFIConvertor.toAFI(LispAFIConvertor.asIPv4Address("1.2.3.4")); MapRequestBuilder mapRequestBuilder = new MapRequestBuilder(); mapRequestBuilder.setNonce((long) 4); mapRequestBuilder.setSourceEid(new SourceEidBuilder().setLispAddressContainer( @@ -471,7 +475,7 @@ public class MappingServiceIntegrationTest extends AbstractMdsalTestBase { public void testMapRegisterDosntOverwritesOtherSubKeys() throws SocketTimeoutException { cleanUP(); - LispAFIAddress eid = LispAFIConvertor.asIPAfiAddress("1.2.3.4"); + LispAFIAddress eid = LispAFIConvertor.toAFI(LispAFIConvertor.asIPv4Address("1.2.3.4")); LispAFIAddress rloc1Value = LispAFIConvertor.asIPAfiAddress("4.3.2.1"); LispAFIAddress rloc1 = LispAFIConvertor.asKeyValue("subkey1", LispAFIConvertor.toPrimitive(rloc1Value)); LispAFIAddress rloc2Value = LispAFIConvertor.asIPAfiAddress("4.3.2.2"); @@ -484,7 +488,7 @@ public class MappingServiceIntegrationTest extends AbstractMdsalTestBase { public void testMapRegisterOverwritesSameSubkey() throws SocketTimeoutException { cleanUP(); - LispAFIAddress eid = LispAFIConvertor.asIPAfiAddress("1.2.3.4"); + LispAFIAddress eid = LispAFIConvertor.toAFI(LispAFIConvertor.asIPv4Address("1.2.3.4")); LispAFIAddress rloc1Value = LispAFIConvertor.asIPAfiAddress("4.3.2.1"); LispAFIAddress rloc1 = LispAFIConvertor.asKeyValue("subkey", LispAFIConvertor.toPrimitive(rloc1Value)); LispAFIAddress rloc2Value = LispAFIConvertor.asIPAfiAddress("4.3.2.2"); @@ -497,7 +501,7 @@ public class MappingServiceIntegrationTest extends AbstractMdsalTestBase { public void testMapRegisterOverwritesNoSubkey() throws SocketTimeoutException { cleanUP(); lms.setOverwrite(true); - LispAFIAddress eid = LispAFIConvertor.asIPAfiAddress("1.2.3.4"); + LispAFIAddress eid = LispAFIConvertor.toAFI(LispAFIConvertor.asIPv4Address("1.2.3.4")); LispAFIAddress rloc1Value = LispAFIConvertor.asIPAfiAddress("4.3.2.1"); LispAFIAddress rloc2Value = LispAFIConvertor.asIPAfiAddress("4.3.2.2"); MapReply mapReply = sendMapRegisterTwiceWithDiffrentValues(eid, rloc1Value, rloc2Value); @@ -509,11 +513,11 @@ public class MappingServiceIntegrationTest extends AbstractMdsalTestBase { public void testMapRegisterDoesntOverwritesNoSubkey() throws SocketTimeoutException { cleanUP(); lms.setOverwrite(false); - LispAFIAddress eid = LispAFIConvertor.asIPAfiAddress("1.2.3.4"); + LispAFIAddress eid = LispAFIConvertor.toAFI(LispAFIConvertor.asIPv4Address("1.2.3.4")); LispAFIAddress rloc1Value = LispAFIConvertor.asIPAfiAddress("4.3.2.1"); LispAFIAddress rloc2Value = LispAFIConvertor.asIPAfiAddress("4.3.2.2"); MapReply mapReply = sendMapRegisterTwiceWithDiffrentValues(eid, rloc1Value, rloc2Value); - assertEquals(2, mapReply.getEidToLocatorRecord().get(0).getLocatorRecord().size()); + assertEquals(1, mapReply.getEidToLocatorRecord().get(0).getLocatorRecord().size()); LispAddressContainer rloc1ReturnValueContainer = mapReply.getEidToLocatorRecord().get(0).getLocatorRecord().get(0).getLispAddressContainer(); LispAddressContainer rloc2ReturnValueContainer = mapReply.getEidToLocatorRecord().get(0).getLocatorRecord().get(1).getLispAddressContainer(); assertTrue((LispAFIConvertor.toContainer(rloc1Value).equals(rloc1ReturnValueContainer) && LispAFIConvertor.toContainer(rloc2Value).equals( @@ -572,6 +576,7 @@ public class MappingServiceIntegrationTest extends AbstractMdsalTestBase { try { Thread.sleep(1000); } catch (InterruptedException e) { + LOG.warn("Interrupted while sleeping"); } mapRegisterPacketWithoutNotify[mapRegisterPacketWithoutNotify.length - 1] += 1; @@ -583,7 +588,7 @@ public class MappingServiceIntegrationTest extends AbstractMdsalTestBase { LispAddressContainer sourceEid = smr.getSourceEid().getLispAddressContainer(); assertTrue(LispAFIConvertor.toContainer(LispAFIConvertor.asIPAfiAddress("153.16.254.1")).equals(sourceEid)); LispAddressContainer smrEid = smr.getEidRecord().get(0).getLispAddressContainer(); - assertTrue(LispAFIConvertor.toContainer(LispAFIConvertor.asIPAfiAddress("1.2.3.4")).equals(smrEid)); + assertTrue(LispAFIConvertor.asIPv4Address("1.2.3.4").equals(smrEid)); } // --------------------- Northbound Tests --------------------------- @@ -1116,7 +1121,7 @@ public class MappingServiceIntegrationTest extends AbstractMdsalTestBase { } // takes an address, packs it in a MapRegister and sends it - private void registerAddress(LispAFIAddress eid, int maskLength) throws SocketTimeoutException { + private void registerAddress(LispAddressContainer eid, int maskLength) throws SocketTimeoutException { MapRegisterBuilder mapRegisterBuilder = new MapRegisterBuilder(); mapRegisterBuilder.setWantMapNotify(true); mapRegisterBuilder.setKeyId((short) 0); @@ -1124,7 +1129,7 @@ public class MappingServiceIntegrationTest extends AbstractMdsalTestBase { mapRegisterBuilder.setNonce((long) 8); mapRegisterBuilder.setProxyMapReply(false); EidToLocatorRecordBuilder etlrBuilder = new EidToLocatorRecordBuilder(); - etlrBuilder.setLispAddressContainer(LispAFIConvertor.toContainer(eid)); + etlrBuilder.setLispAddressContainer(eid); if (maskLength != -1) { etlrBuilder.setMaskLength((short) maskLength); } else { @@ -1152,12 +1157,12 @@ public class MappingServiceIntegrationTest extends AbstractMdsalTestBase { assertEquals(8, mapNotify.getNonce().longValue()); } - private MapReply queryForAddress(LispAFIAddress eid, String srcEid) throws SocketTimeoutException { + private MapReply queryForAddress(LispAddressContainer eid, String srcEid) throws SocketTimeoutException { MapRequestBuilder mapRequestBuilder = new MapRequestBuilder(); mapRequestBuilder.setNonce((long) 4); mapRequestBuilder.setEidRecord(new ArrayList()); mapRequestBuilder.getEidRecord().add( - new EidRecordBuilder().setMask((short) 32).setLispAddressContainer(LispAFIConvertor.toContainer(eid)).build()); + new EidRecordBuilder().setMask((short) 32).setLispAddressContainer(eid).build()); mapRequestBuilder.setItrRloc(new ArrayList()); if (srcEid != null) { mapRequestBuilder.setSourceEid(new SourceEidBuilder().setLispAddressContainer(LispAFIConvertor. @@ -1241,7 +1246,7 @@ public class MappingServiceIntegrationTest extends AbstractMdsalTestBase { cleanUP(); String ipString = "10.20.30.200"; String macString = "01:02:03:04:05:06"; - org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev150820.lispsimpleaddress.primitiveaddress.Ipv4 addrToSend1 = LispAFIConvertor.asPrimitiveIPAfiAddress(ipString); + org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev150820.lispsimpleaddress.primitiveaddress.Ipv4 addrToSend1 = LispAFIConvertor.asPrimitiveIPv4AfiPrefix(ipString, 32); org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev150820.lispsimpleaddress.primitiveaddress.Mac addrToSend2 = LispAFIConvertor.asPrimitiveMacAfiAddress(macString); LcafSourceDestAddrBuilder builder = new LcafSourceDestAddrBuilder(); builder.setAfi(AddressFamilyNumberEnum.LCAF.getIanaCode()); @@ -1275,8 +1280,8 @@ public class MappingServiceIntegrationTest extends AbstractMdsalTestBase { cleanUP(); String ipString1 = "10.10.10.0"; String ipString2 = "20.20.20.0"; - org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev150820.lispsimpleaddress.primitiveaddress.Ipv4 addrToSend1 = LispAFIConvertor.asPrimitiveIPAfiAddress(ipString1); - org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev150820.lispsimpleaddress.primitiveaddress.Ipv4 addrToSend2 = LispAFIConvertor.asPrimitiveIPAfiAddress(ipString2); + org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev150820.lispsimpleaddress.primitiveaddress.Ipv4 addrToSend1 = LispAFIConvertor.asPrimitiveIPv4AfiPrefix(ipString1, 24); + org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev150820.lispsimpleaddress.primitiveaddress.Ipv4 addrToSend2 = LispAFIConvertor.asPrimitiveIPv4AfiPrefix(ipString2, 24); LcafSourceDestAddrBuilder builder = new LcafSourceDestAddrBuilder(); builder.setAfi(AddressFamilyNumberEnum.LCAF.getIanaCode()); builder.setLcafType((short) LispCanonicalAddressFormatEnum.SOURCE_DEST.getLispCode()); @@ -1285,8 +1290,8 @@ public class MappingServiceIntegrationTest extends AbstractMdsalTestBase { builder.setSrcAddress(new SrcAddressBuilder().setPrimitiveAddress(addrToSend1).build()); builder.setDstAddress(new DstAddressBuilder().setPrimitiveAddress(addrToSend2).build()); - LcafSourceDestAddr srcDst = builder.build(); - registerAddress(LispAFIConvertor.asIPAfiAddress(ipString2), 24); + LispAddressContainer srcDst = LispAFIConvertor.toContainer(builder.build()); + registerAddress(LispAFIConvertor.asIPv4Prefix(ipString2, 24), 24); registerAddress(srcDst, -1); // exact match @@ -1309,7 +1314,7 @@ public class MappingServiceIntegrationTest extends AbstractMdsalTestBase { assertEquals(ipString2, receivedIP2.getIpv4Address().getValue()); // srcEid/dstEid match - reply = queryForAddress(LispAFIConvertor.asIPAfiAddress("20.20.20.1"), "10.10.10.1"); + reply = queryForAddress(LispAFIConvertor.asIPv4Address("20.20.20.1"), "10.10.10.1"); fromNetwork = reply.getEidToLocatorRecord().get(0).getLispAddressContainer(); assertTrue(fromNetwork.getAddress() instanceof org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev150820.lispaddress.lispaddresscontainer.address.Ipv4); @@ -1317,7 +1322,7 @@ public class MappingServiceIntegrationTest extends AbstractMdsalTestBase { assertEquals(ipString2, ipAddr2.getIpv4Address().getValue()); // dstEid match only - reply = queryForAddress(LispAFIConvertor.asIPAfiAddress("20.20.20.1"), "1.2.3.4"); + reply = queryForAddress(LispAFIConvertor.asIPv4Address("20.20.20.1"), "1.2.3.4"); fromNetwork = reply.getEidToLocatorRecord().get(0).getLispAddressContainer(); assertTrue(fromNetwork.getAddress() instanceof org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev150820.lispaddress.lispaddresscontainer.address.Ipv4); diff --git a/mappingservice/lisp-proto/src/main/java/org/opendaylight/lispflowmapping/lisp/serializer/EidRecordSerializer.java b/mappingservice/lisp-proto/src/main/java/org/opendaylight/lispflowmapping/lisp/serializer/EidRecordSerializer.java index 7b70cafc9..ea1f41018 100644 --- a/mappingservice/lisp-proto/src/main/java/org/opendaylight/lispflowmapping/lisp/serializer/EidRecordSerializer.java +++ b/mappingservice/lisp-proto/src/main/java/org/opendaylight/lispflowmapping/lisp/serializer/EidRecordSerializer.java @@ -16,7 +16,6 @@ import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev150820.Li import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev150820.eidrecords.EidRecord; import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev150820.eidrecords.EidRecordBuilder; - public class EidRecordSerializer { private static final EidRecordSerializer INSTANCE = new EidRecordSerializer(); @@ -33,7 +32,8 @@ public class EidRecordSerializer { /* byte reserved = */requestBuffer.get(); short maskLength = (short) (ByteUtil.getUnsignedByte(requestBuffer)); LispAFIAddress prefix = LispAddressSerializer.getInstance().deserialize(requestBuffer); - return new EidRecordBuilder().setLispAddressContainer(LispAFIConvertor.toContainer(prefix)) - .setMask(maskLength).build(); + prefix = SerializerHelper.fixMask(prefix, maskLength); + return new EidRecordBuilder().setLispAddressContainer(LispAFIConvertor.toContainer(prefix)).setMask(maskLength) + .build(); } } diff --git a/mappingservice/lisp-proto/src/main/java/org/opendaylight/lispflowmapping/lisp/serializer/EidToLocatorRecordSerializer.java b/mappingservice/lisp-proto/src/main/java/org/opendaylight/lispflowmapping/lisp/serializer/EidToLocatorRecordSerializer.java index 0fb0658e0..c82f64733 100644 --- a/mappingservice/lisp-proto/src/main/java/org/opendaylight/lispflowmapping/lisp/serializer/EidToLocatorRecordSerializer.java +++ b/mappingservice/lisp-proto/src/main/java/org/opendaylight/lispflowmapping/lisp/serializer/EidToLocatorRecordSerializer.java @@ -50,6 +50,7 @@ public class EidToLocatorRecordSerializer { builder.setMapVersion(buffer.getShort()); LispAFIAddress afiAddress = LispAddressSerializer.getInstance().deserialize(buffer); + afiAddress = SerializerHelper.fixMask(afiAddress, builder.getMaskLength()); LispAddressContainer container = LispAFIConvertor.toContainer(afiAddress); builder.setLispAddressContainer(container); diff --git a/mappingservice/lisp-proto/src/main/java/org/opendaylight/lispflowmapping/lisp/serializer/SerializerHelper.java b/mappingservice/lisp-proto/src/main/java/org/opendaylight/lispflowmapping/lisp/serializer/SerializerHelper.java new file mode 100644 index 000000000..462cc47ca --- /dev/null +++ b/mappingservice/lisp-proto/src/main/java/org/opendaylight/lispflowmapping/lisp/serializer/SerializerHelper.java @@ -0,0 +1,40 @@ +/* + * 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.lisp.serializer; + +import org.opendaylight.lispflowmapping.lisp.util.LcafSourceDestHelper; +import org.opendaylight.lispflowmapping.lisp.util.MaskUtil; +import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev150820.LcafSegmentAddress; +import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev150820.LcafSourceDestAddress; +import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev150820.LispAFIAddress; +import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev150820.LispIpv4Address; +import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev150820.LispIpv6Address; + +/** + * @author Florin Coras + * + * Helper class needed to fix masks of EIDs in southbound incoming LISP packets. + * + * RFC6830 defines masks and EIDs as separate fields of larger, encompassing blocks of LISP messages. However + * within LispFlowMapping masks are internal fields of EIDs. The method fixMask should be used in deserializers + * to ensure that masks for deserialized EIDs reflect accordingly the mask field values carried in LISP + * messages. + */ + +public class SerializerHelper { + public static LispAFIAddress fixMask(LispAFIAddress addr, short mask) { + if (addr instanceof LispIpv4Address || addr instanceof LispIpv6Address || addr instanceof LcafSegmentAddress) { + return MaskUtil.setMask(addr, mask); + } else if (addr instanceof LcafSourceDestAddress) { + return MaskUtil.setMaskSourceDest(addr, LcafSourceDestHelper.getSrcMask(addr), + LcafSourceDestHelper.getDstMask(addr)); + } + return addr; + } +} diff --git a/mappingservice/lisp-proto/src/main/java/org/opendaylight/lispflowmapping/lisp/serializer/address/LispSourceDestLCAFAddressSerializer.java b/mappingservice/lisp-proto/src/main/java/org/opendaylight/lispflowmapping/lisp/serializer/address/LispSourceDestLCAFAddressSerializer.java index 4fdcdd328..05023abb8 100644 --- a/mappingservice/lisp-proto/src/main/java/org/opendaylight/lispflowmapping/lisp/serializer/address/LispSourceDestLCAFAddressSerializer.java +++ b/mappingservice/lisp-proto/src/main/java/org/opendaylight/lispflowmapping/lisp/serializer/address/LispSourceDestLCAFAddressSerializer.java @@ -9,6 +9,7 @@ package org.opendaylight.lispflowmapping.lisp.serializer.address; import java.nio.ByteBuffer; +import org.opendaylight.lispflowmapping.lisp.serializer.SerializerHelper; import org.opendaylight.lispflowmapping.lisp.type.AddressFamilyNumberEnum; import org.opendaylight.lispflowmapping.lisp.type.LispCanonicalAddressFormatEnum; import org.opendaylight.lispflowmapping.lisp.util.ByteUtil; @@ -53,10 +54,12 @@ public class LispSourceDestLCAFAddressSerializer extends LispLCAFAddressSerializ @Override protected LcafSourceDestAddress deserializeData(ByteBuffer buffer, byte res2, short length) { short res = buffer.getShort(); - int srcMaskLength = ByteUtil.getUnsignedByte(buffer); - int dstMaskLength = ByteUtil.getUnsignedByte(buffer); + short srcMaskLength = (short) ByteUtil.getUnsignedByte(buffer); + short dstMaskLength = (short) ByteUtil.getUnsignedByte(buffer); LispAFIAddress srcAddress = LispAddressSerializer.getInstance().deserialize(buffer); + srcAddress = SerializerHelper.fixMask(srcAddress, srcMaskLength); LispAFIAddress dstAddress = LispAddressSerializer.getInstance().deserialize(buffer); + dstAddress = SerializerHelper.fixMask(dstAddress, dstMaskLength); LcafSourceDestAddrBuilder builder = new LcafSourceDestAddrBuilder(); builder.setDstMaskLength((short) dstMaskLength).setSrcMaskLength((short) srcMaskLength); builder.setSrcAddress(new SrcAddressBuilder().setPrimitiveAddress((PrimitiveAddress) LispAFIConvertor.toPrimitive(srcAddress)).build()); diff --git a/mappingservice/lisp-proto/src/main/java/org/opendaylight/lispflowmapping/lisp/util/LcafSourceDestHelper.java b/mappingservice/lisp-proto/src/main/java/org/opendaylight/lispflowmapping/lisp/util/LcafSourceDestHelper.java new file mode 100644 index 000000000..24bc490ea --- /dev/null +++ b/mappingservice/lisp-proto/src/main/java/org/opendaylight/lispflowmapping/lisp/util/LcafSourceDestHelper.java @@ -0,0 +1,146 @@ +/* + * 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.lisp.util; + +import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev150820.LcafSourceDestAddress; +import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev150820.LispAFIAddress; +import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev150820.lcafsourcedestaddress.DstAddress; +import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev150820.lcafsourcedestaddress.SrcAddress; +import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev150820.lispaddress.LispAddressContainer; +import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev150820.lispaddress.lispaddresscontainer.address.LcafSourceDest; +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; + +/** + * @author Florin Coras + * + */ + +public class LcafSourceDestHelper { + private final static Logger LOG = LoggerFactory.getLogger(LcafSourceDestHelper.class); + public static LispAFIAddress getSrcAfi(LispAddressContainer addr) { + if (!isSrcDst(addr)) { + return LispAFIConvertor.toAFI(addr); + } + return LispAFIConvertor.toAFIfromPrimitive(((LcafSourceDest) addr.getAddress()).getLcafSourceDestAddr() + .getSrcAddress().getPrimitiveAddress()); + } + + public static LispAFIAddress getSrcAfi(LispAFIAddress addr) { + if (!isSrcDst(addr)) { + return addr; + } + return LispAFIConvertor.toAFIfromPrimitive(((LcafSourceDestAddress) addr) + .getSrcAddress().getPrimitiveAddress()); + } + + public static LispAFIAddress getDstAfi(LispAddressContainer addr) { + if (!isSrcDst(addr)) { + return LispAFIConvertor.toAFI(addr); + } + return LispAFIConvertor.toAFIfromPrimitive(((LcafSourceDest) addr.getAddress()).getLcafSourceDestAddr() + .getDstAddress().getPrimitiveAddress()); + } + + public static LispAFIAddress getDstAfi(LispAFIAddress addr) { + if (!isSrcDst(addr)) { + return addr; + } + return LispAFIConvertor.toAFIfromPrimitive(((LcafSourceDestAddress) addr) + .getDstAddress().getPrimitiveAddress()); + } + + public static LispAddressContainer getSrc(LispAddressContainer addr) { + if (!isSrcDst(addr)) { + return addr; + } + return LispAFIConvertor.toContainer(LispAFIConvertor.toAFIfromPrimitive(((LcafSourceDest) addr + .getAddress()).getLcafSourceDestAddr().getSrcAddress().getPrimitiveAddress())); } + + public static LispAddressContainer getDst(LispAddressContainer addr) { + if (!isSrcDst(addr)) { + return addr; + } + return LispAFIConvertor.toContainer(LispAFIConvertor.toAFIfromPrimitive(((LcafSourceDest) addr + .getAddress()).getLcafSourceDestAddr().getDstAddress().getPrimitiveAddress())); + } + + public static short getSrcMask(LispAddressContainer addr) { + if (!isSrcDst(addr)) { + return 0; + } + return ((LcafSourceDest) addr.getAddress()).getLcafSourceDestAddr().getSrcMaskLength(); + } + + public static short getDstMask(LispAddressContainer addr) { + if (!isSrcDst(addr)) { + return 0; + } + return ((LcafSourceDest) addr.getAddress()).getLcafSourceDestAddr().getDstMaskLength(); + } + + public static short getSrcMask(LispAFIAddress addr) { + if (!isSrcDst(addr)) { + return 0; + } + return ((LcafSourceDestAddress) addr).getSrcMaskLength(); + } + + public static short getDstMask(LispAFIAddress addr) { + if (!isSrcDst(addr)) { + return 0; + } + return ((LcafSourceDestAddress) addr).getDstMaskLength(); + } + + public static DstAddress getDstAddress(LispAFIAddress addr) { + if (!isSrcDst(addr)) { + return null; + } + return ((LcafSourceDestAddress)addr).getDstAddress(); + } + + public static SrcAddress getSrcAddress(LispAFIAddress addr) { + if (!isSrcDst(addr)) { + return null; + } + return ((LcafSourceDestAddress)addr).getSrcAddress(); + } + + public static DstAddress getDstAddress(LispAddressContainer addr) { + if (!isSrcDst(addr)) { + return null; + } + return ((LcafSourceDest)addr.getAddress()).getLcafSourceDestAddr().getDstAddress(); + } + + public static SrcAddress getSrcAddress(LispAddressContainer addr) { + if (!isSrcDst(addr)) { + return null; + } + return ((LcafSourceDest)addr.getAddress()).getLcafSourceDestAddr().getSrcAddress(); + } + + + private static boolean isSrcDst(LispAFIAddress addr) { + if (!(addr instanceof LcafSourceDestAddress)) { + LOG.warn("Address {} is not a valid SourceDest LCAF", addr); + return false; + } + return true; + } + + private static boolean isSrcDst(LispAddressContainer addr) { + if (!(addr.getAddress() instanceof LcafSourceDest)) { + LOG.warn("Address {} is not a valid SourceDest LCAF", addr); + return false; + } + return true; + } +} diff --git a/mappingservice/lisp-proto/src/main/java/org/opendaylight/lispflowmapping/lisp/util/LispAFIConvertor.java b/mappingservice/lisp-proto/src/main/java/org/opendaylight/lispflowmapping/lisp/util/LispAFIConvertor.java index 9c742f870..522f47756 100644 --- a/mappingservice/lisp-proto/src/main/java/org/opendaylight/lispflowmapping/lisp/util/LispAFIConvertor.java +++ b/mappingservice/lisp-proto/src/main/java/org/opendaylight/lispflowmapping/lisp/util/LispAFIConvertor.java @@ -162,20 +162,16 @@ public class LispAFIConvertor { if (address instanceof org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev150820.lispaddress.lispaddresscontainer.address.ipv4.Ipv4Address) { return new Ipv4Builder() .setIpv4Address( - new Ipv4AddressBuilder() - .setIpv4Address( - ((org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev150820.lispaddress.lispaddresscontainer.address.ipv4.Ipv4Address) address) - .getIpv4Address()) - .setAfi(address.getAfi()).build()).build(); + new org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev150820.lispsimpleaddress.primitiveaddress.ipv4.Ipv4AddressBuilder( + (org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev150820.LispIpv4Address) address) + .build()).build(); } if (address instanceof org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev150820.lispaddress.lispaddresscontainer.address.ipv6.Ipv6Address) { return new org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev150820.lispsimpleaddress.primitiveaddress.Ipv6Builder() .setIpv6Address( - new org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev150820.lispsimpleaddress.primitiveaddress.ipv6.Ipv6AddressBuilder() - .setIpv6Address( - ((org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev150820.lispaddress.lispaddresscontainer.address.ipv6.Ipv6Address) address) - .getIpv6Address()) - .setAfi(address.getAfi()).build()).build(); + new org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev150820.lispsimpleaddress.primitiveaddress.ipv6.Ipv6AddressBuilder( + (org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev150820.LispIpv6Address) address) + .build()).build(); } if (address instanceof org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev150820.lispaddress.lispaddresscontainer.address.mac.MacAddress) { return new MacBuilder() @@ -201,20 +197,12 @@ public class LispAFIConvertor { public static LispAFIAddress toAFIfromPrimitive(PrimitiveAddress primitive) { if (primitive instanceof org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev150820.lispsimpleaddress.primitiveaddress.Ipv4) { - return new org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev150820.lispaddress.lispaddresscontainer.address.ipv4.Ipv4AddressBuilder() - .setAfi(((org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev150820.lispsimpleaddress.primitiveaddress.Ipv4) primitive) - .getIpv4Address().getAfi()) - .setIpv4Address( - ((org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev150820.lispsimpleaddress.primitiveaddress.Ipv4) primitive) - .getIpv4Address().getIpv4Address()).build(); + return new org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev150820.lispaddress.lispaddresscontainer.address.ipv4.Ipv4AddressBuilder(((org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev150820.lispsimpleaddress.primitiveaddress.Ipv4) primitive) + .getIpv4Address()).build(); } if (primitive instanceof org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev150820.lispsimpleaddress.primitiveaddress.Ipv6) { - return new org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev150820.lispaddress.lispaddresscontainer.address.ipv6.Ipv6AddressBuilder() - .setAfi(((org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev150820.lispsimpleaddress.primitiveaddress.Ipv6) primitive) - .getIpv6Address().getAfi()) - .setIpv6Address( - ((org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev150820.lispsimpleaddress.primitiveaddress.Ipv6) primitive) - .getIpv6Address().getIpv6Address()).build(); + return new org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev150820.lispaddress.lispaddresscontainer.address.ipv6.Ipv6AddressBuilder(((org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev150820.lispsimpleaddress.primitiveaddress.Ipv6) primitive) + .getIpv6Address()).build(); } if (primitive instanceof org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev150820.lispsimpleaddress.primitiveaddress.Mac) { return new org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev150820.lispaddress.lispaddresscontainer.address.mac.MacAddressBuilder() @@ -262,6 +250,47 @@ public class LispAFIConvertor { .build(); } + public static org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev150820.lispaddress.lispaddresscontainer.address.ipv6.Ipv6Address asIPv6AfiAddress( + String ip) { + return new Ipv6AddressBuilder().setIpv6Address(new Ipv6Address(ip)) + .setAfi((short) AddressFamilyNumberEnum.IP6.getIanaCode()) + .build(); + } + + public static LispAddressContainer asIPv4Address(String ip) { + return new LispAddressContainerBuilder().setAddress(new org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev150820.lispaddress.lispaddresscontainer.address.Ipv4Builder() + .setIpv4Address(new org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev150820.lispaddress.lispaddresscontainer.address.ipv4.Ipv4AddressBuilder() + .setIpv4Address(new Ipv4Address(ip)).setAfi((short) AddressFamilyNumberEnum.IP.getIanaCode()).setMask((short)32).build()).build()).build(); + } + + public static LispAFIAddress asIPv4AfiPrefix(String ip, int mask) { + return new org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev150820.lispaddress.lispaddresscontainer.address.ipv4.Ipv4AddressBuilder() + .setIpv4Address(new Ipv4Address(MaskUtil.normalizeIPString(ip, mask))).setAfi((short) AddressFamilyNumberEnum.IP.getIanaCode()).setMask((short)mask).build(); + } + + public static LispAddressContainer asIPv4Prefix(String ip, int mask) { + return new LispAddressContainerBuilder().setAddress(new org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev150820.lispaddress.lispaddresscontainer.address.Ipv4Builder() + .setIpv4Address(new org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev150820.lispaddress.lispaddresscontainer.address.ipv4.Ipv4AddressBuilder() + .setIpv4Address(new Ipv4Address(MaskUtil.normalizeIPString(ip, mask))).setAfi((short) AddressFamilyNumberEnum.IP.getIanaCode()).setMask((short)mask).build()).build()).build(); + } + + public static LispAddressContainer asIPv6Address(String ip) { + return new LispAddressContainerBuilder().setAddress(new org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev150820.lispaddress.lispaddresscontainer.address.Ipv6Builder() + .setIpv6Address(new org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev150820.lispaddress.lispaddresscontainer.address.ipv6.Ipv6AddressBuilder() + .setIpv6Address(new Ipv6Address(ip)).setAfi((short) AddressFamilyNumberEnum.IP6.getIanaCode()).setMask((short)128).build()).build()).build(); + } + + public static LispAFIAddress asIPv6AfiPrefix(String ip, int mask) { + return new org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev150820.lispaddress.lispaddresscontainer.address.ipv6.Ipv6AddressBuilder() + .setIpv6Address(new Ipv6Address(MaskUtil.normalizeIPString(ip, mask))).setAfi((short) AddressFamilyNumberEnum.IP6.getIanaCode()).setMask((short)mask).build(); + } + + public static LispAddressContainer asIPv6Prefix(String ip, int mask) { + return new LispAddressContainerBuilder().setAddress(new org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev150820.lispaddress.lispaddresscontainer.address.Ipv6Builder() + .setIpv6Address(new org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev150820.lispaddress.lispaddresscontainer.address.ipv6.Ipv6AddressBuilder() + .setIpv6Address(new Ipv6Address(MaskUtil.normalizeIPString(ip, mask))).setAfi((short) AddressFamilyNumberEnum.IP6.getIanaCode()).setMask((short)mask).build()).build()).build(); + } + public static LcafKeyValueAddressAddr asKeyValue(String key, PrimitiveAddress value) { return new LcafKeyValueAddressAddrBuilder() @@ -293,6 +322,26 @@ public class LispAFIConvertor { .getIanaCode()).build()).build(); } + public static org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev150820.lispsimpleaddress.primitiveaddress.Ipv4 asPrimitiveIPv4AfiPrefix( + String ip, int mask) { + return new org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev150820.lispsimpleaddress.primitiveaddress.Ipv4Builder() + .setIpv4Address( + new org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev150820.lispsimpleaddress.primitiveaddress.ipv4.Ipv4AddressBuilder() + .setIpv4Address(new Ipv4Address(ip)) + .setAfi((short) AddressFamilyNumberEnum.IP.getIanaCode()).setMask((short) mask).build()) + .build(); + } + + public static org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev150820.lispsimpleaddress.primitiveaddress.Ipv6 asPrimitiveIPv6AfiPrefix( + String ip, int mask) { + return new org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev150820.lispsimpleaddress.primitiveaddress.Ipv6Builder() + .setIpv6Address( + new org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev150820.lispsimpleaddress.primitiveaddress.ipv6.Ipv6AddressBuilder() + .setIpv6Address(new Ipv6Address(ip)) + .setAfi((short) AddressFamilyNumberEnum.IP6.getIanaCode()).setMask((short) mask).build()) + .build(); + } + public static org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev150820.lispaddress.lispaddresscontainer.address.mac.MacAddress asMacAfiAddress( String mac) { return new org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev150820.lispaddress.lispaddresscontainer.address.mac.MacAddressBuilder() @@ -310,11 +359,4 @@ public class LispAFIConvertor { .setAfi((short) AddressFamilyNumberEnum.MAC .getIanaCode()).build()).build(); } - - public static org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev150820.lispaddress.lispaddresscontainer.address.ipv6.Ipv6Address asIPv6AfiAddress( - String ip) { - return new Ipv6AddressBuilder().setIpv6Address(new Ipv6Address(ip)) - .setAfi((short) AddressFamilyNumberEnum.IP6.getIanaCode()) - .build(); - } } diff --git a/mappingservice/lisp-proto/src/main/java/org/opendaylight/lispflowmapping/lisp/util/LispAddressStringifier.java b/mappingservice/lisp-proto/src/main/java/org/opendaylight/lispflowmapping/lisp/util/LispAddressStringifier.java index dd9e36c9b..ea92e9a69 100644 --- a/mappingservice/lisp-proto/src/main/java/org/opendaylight/lispflowmapping/lisp/util/LispAddressStringifier.java +++ b/mappingservice/lisp-proto/src/main/java/org/opendaylight/lispflowmapping/lisp/util/LispAddressStringifier.java @@ -66,22 +66,18 @@ public class LispAddressStringifier { } public static String getString(LispAddressContainer container) { - return getString(Destination.USER, container); + return getAddrString(Destination.USER, container); } - public static String getString(LispAddressContainer container, int mask) { - return getString(Destination.USER, container, mask); + public static String getURIString(LispAddressContainer container) { + return getString(Destination.URI, container); } - public static String getURIString(LispAddressContainer container, int mask) { - return getString(Destination.URI, container, mask); + public static String getURLString(LispAddressContainer container) { + return getString(Destination.URL, container); } - public static String getURLString(LispAddressContainer container, int mask) { - return getString(Destination.URL, container, mask); - } - - private static String getString(Destination dst, LispAddressContainer container) { + private static String getAddrString(Destination dst, LispAddressContainer container) { Preconditions.checkNotNull(container, "address should not be null"); Address addr = container.getAddress(); String prefix = null; @@ -135,21 +131,12 @@ public class LispAddressStringifier { } - private static String getString(Destination dst, LispAddressContainer container, int mask) { - Address addr = container.getAddress(); - - if (isMaskable(addr)) { - return (getString(dst, container) + getMaskSeparator(dst) + mask); + private static String getString(Destination dst, LispAddressContainer container) { + if (MaskUtil.isMaskable(container)) { + return (getAddrString(dst, container) + getMaskSeparator(dst) + MaskUtil.getMaskForAddress(container)); } else { - return getString(dst, container); - } - } - - private static boolean isMaskable(Address addr) { - if (addr instanceof Ipv4 || addr instanceof Ipv6 || addr instanceof LcafSegment) { - return true; + return getAddrString(dst, container); } - return false; } private static String getMaskSeparator(Destination dst) { diff --git a/mappingservice/lisp-proto/src/main/java/org/opendaylight/lispflowmapping/lisp/util/MaskUtil.java b/mappingservice/lisp-proto/src/main/java/org/opendaylight/lispflowmapping/lisp/util/MaskUtil.java new file mode 100644 index 000000000..62c903927 --- /dev/null +++ b/mappingservice/lisp-proto/src/main/java/org/opendaylight/lispflowmapping/lisp/util/MaskUtil.java @@ -0,0 +1,308 @@ +/* + * 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.lisp.util; + +import java.net.Inet4Address; +import java.net.Inet6Address; +import java.net.InetAddress; +import java.net.UnknownHostException; +import java.nio.ByteBuffer; + +import org.apache.commons.lang3.exception.ExceptionUtils; +import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev150820.LcafSegmentAddress; +import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev150820.LcafSourceDestAddress; +import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev150820.LispAFIAddress; +import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev150820.LispIpv4Address; +import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev150820.LispIpv6Address; +import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev150820.lcafsegmentaddress.AddressBuilder; +import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev150820.lcafsegmentaddress.Address; +import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev150820.lcafsourcedestaddress.DstAddress; +import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev150820.lcafsourcedestaddress.DstAddressBuilder; +import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev150820.lcafsourcedestaddress.SrcAddress; +import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev150820.lcafsourcedestaddress.SrcAddressBuilder; +import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev150820.lispaddress.LispAddressContainer; +import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev150820.lispaddress.LispAddressContainerBuilder; +import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev150820.lispaddress.lispaddresscontainer.address.Ipv4; +import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev150820.lispaddress.lispaddresscontainer.address.Ipv4Builder; +import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev150820.lispaddress.lispaddresscontainer.address.Ipv6; +import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev150820.lispaddress.lispaddresscontainer.address.Ipv6Builder; +import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev150820.lispaddress.lispaddresscontainer.address.LcafSegmentBuilder; +import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev150820.lispaddress.lispaddresscontainer.address.LcafSourceDest; +import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev150820.lispaddress.lispaddresscontainer.address.LcafSourceDestBuilder; +import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev150820.lispaddress.lispaddresscontainer.address.ipv4.Ipv4Address; +import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev150820.lispaddress.lispaddresscontainer.address.ipv4.Ipv4AddressBuilder; +import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev150820.lispaddress.lispaddresscontainer.address.ipv6.Ipv6Address; +import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev150820.lispaddress.lispaddresscontainer.address.ipv6.Ipv6AddressBuilder; +import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev150820.lispaddress.lispaddresscontainer.address.lcafsegment.LcafSegmentAddr; +import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev150820.lispaddress.lispaddresscontainer.address.lcafsegment.LcafSegmentAddrBuilder; +import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev150820.lispaddress.lispaddresscontainer.address.lcafsourcedest.LcafSourceDestAddr; +import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev150820.lispaddress.lispaddresscontainer.address.lcafsourcedest.LcafSourceDestAddrBuilder; +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; + +public class MaskUtil { + private static final Logger LOG = LoggerFactory.getLogger(MaskUtil.class); + public static boolean isMaskable(LispAFIAddress address) { + if (address instanceof Ipv4Address || address instanceof Ipv6Address || address instanceof LcafSegmentAddr) { + return true; + } + return false; + } + + public static boolean isMaskable(LispAddressContainer address) { + if (address.getAddress() instanceof Ipv4 || address.getAddress() instanceof Ipv6) { + return true; + } else if (address.getAddress() instanceof LcafSegmentAddress) { + return isMaskable(LispAFIConvertor.toAFIfromPrimitive(((LcafSegmentAddress) address).getAddress() + .getPrimitiveAddress())); + } else if (address.getAddress() instanceof LcafSourceDestAddress) { + LcafSourceDestAddr sd = ((LcafSourceDest) address.getAddress()).getLcafSourceDestAddr(); + return isMaskable(LispAFIConvertor.toAFIfromPrimitive(sd.getSrcAddress().getPrimitiveAddress())) + && isMaskable(LispAFIConvertor.toAFIfromPrimitive(sd.getDstAddress().getPrimitiveAddress())); + } + return false; + } + + public static LispAFIAddress normalize(LispAFIAddress address, short mask) { + try { + if (address instanceof Ipv4Address) { + return LispAFIConvertor.asIPAfiAddress(normalizeIP( + Inet4Address.getByName(((Ipv4Address) address).getIpv4Address().getValue()), + mask).getHostAddress()); + } else if (address instanceof Ipv6Address) { + return LispAFIConvertor.asIPv6AfiAddress(normalizeIP( + Inet6Address.getByName(((Ipv6Address) address).getIpv6Address().getValue()), + mask).getHostAddress()); + } else if (address instanceof LcafSegmentAddr) { + LcafSegmentAddr segAddr = (LcafSegmentAddr) address; + LispAFIAddress afiAddr = LispAFIConvertor + .toAFIfromPrimitive(segAddr.getAddress().getPrimitiveAddress()); + Address normalizedAddr = new AddressBuilder().setPrimitiveAddress( + LispAFIConvertor.toPrimitive(normalize(afiAddr, mask))).build(); + return new LcafSegmentAddrBuilder(segAddr).setAddress(normalizedAddr).build(); + } + } catch (UnknownHostException e) { + LOG.trace("Failed to normalize " + address + ": " + ExceptionUtils.getStackTrace(e)); + } + return address; + } + + public static LispAFIAddress normalize(LispAFIAddress address) { + if (address instanceof Ipv4Address) { + return normalize(address, ((Ipv4Address) address).getMask()); + } else if (address instanceof Ipv6Address) { + return normalize(address, ((Ipv6Address) address).getMask()); + } else if (address instanceof LcafSegmentAddr) { + LcafSegmentAddr segAddr = (LcafSegmentAddr) address; + LispAFIAddress afiAddr = LispAFIConvertor.toAFIfromPrimitive(segAddr.getAddress().getPrimitiveAddress()); + short mask = getMaskForAfiAddress(afiAddr); + if (mask == 0) { + return address; + } + Address normalizedAddr = new AddressBuilder().setPrimitiveAddress( + LispAFIConvertor.toPrimitive(normalize(afiAddr, mask))).build(); + return new LcafSegmentAddrBuilder(segAddr).setAddress(normalizedAddr).build(); + } + return address; + } + + public static LispAddressContainer normalize(LispAddressContainer address, short mask) { + try { + if (address.getAddress() instanceof Ipv4) { + return LispAFIConvertor.asIPv4Prefix(normalizeIP( + Inet4Address.getByName(((Ipv4) address.getAddress()).getIpv4Address().getIpv4Address().getValue()), + mask).getHostAddress(), mask); + } else if (address.getAddress() instanceof Ipv6) { + return LispAFIConvertor.asIPv6Prefix(normalizeIP( + Inet6Address.getByName(((Ipv6) address.getAddress()).getIpv6Address().getIpv6Address().getValue()), + mask).getHostAddress(), mask); + } else if (address instanceof LcafSegmentAddress) { + LcafSegmentAddress segAddr = (LcafSegmentAddress) address; + LispAFIAddress afiAddr = LispAFIConvertor + .toAFIfromPrimitive(segAddr.getAddress().getPrimitiveAddress()); + Address normalizedAddr = new AddressBuilder().setPrimitiveAddress( + LispAFIConvertor.toPrimitive(normalize(afiAddr, mask))).build(); + return new LispAddressContainerBuilder().setAddress( + new LcafSegmentBuilder().setLcafSegmentAddr( + new LcafSegmentAddrBuilder(segAddr).setAddress(normalizedAddr).build()).build()) + .build(); + } + } catch (UnknownHostException e) { + LOG.trace("Failed to normalize " + address + ": " + ExceptionUtils.getStackTrace(e)); + } + return address; + } + + public static LispAddressContainer normalize(LispAddressContainer address) { + if (address.getAddress() instanceof Ipv4) { + return normalize(address, ((Ipv4)address.getAddress()).getIpv4Address().getMask()); + } else if (address.getAddress() instanceof Ipv6) { + return normalize(address, ((Ipv6)address.getAddress()).getIpv6Address().getMask()); + } else if (address instanceof LcafSegmentAddress) { + LcafSegmentAddress segAddr = (LcafSegmentAddress) address; + LispAFIAddress afiAddr = LispAFIConvertor + .toAFIfromPrimitive(segAddr.getAddress().getPrimitiveAddress()); + short mask = getMaskForAfiAddress(afiAddr); + if (mask == 0) { + return address; + } + Address normalizedAddr = new AddressBuilder().setPrimitiveAddress( + LispAFIConvertor.toPrimitive(normalize(afiAddr, mask))).build(); + return new LispAddressContainerBuilder().setAddress( + new LcafSegmentBuilder().setLcafSegmentAddr( + new LcafSegmentAddrBuilder(segAddr).setAddress(normalizedAddr).build()).build()) + .build(); + } + return address; + } + + private static InetAddress normalizeIP(InetAddress address, int mask) throws UnknownHostException { + ByteBuffer byteRepresentation = ByteBuffer.wrap(address.getAddress()); + byte b = (byte) 0xff; + for (int i = 0; i < byteRepresentation.array().length; i++) { + if (mask >= 8) + byteRepresentation.put(i, (byte) (b & byteRepresentation.get(i))); + + else if (mask > 0) { + byteRepresentation.put(i, (byte) ((byte) (b << (8 - mask)) & byteRepresentation.get(i))); + } else { + byteRepresentation.put(i, (byte) (0 & byteRepresentation.get(i))); + } + + mask -= 8; + } + return InetAddress.getByAddress(byteRepresentation.array()); + } + + public static String normalizeIPString(String addr, int mask) { + short afi = getIpAfiForString(addr); + try { + if (afi == 1) { + return normalizeIP(Inet4Address.getByName(addr), mask).getHostAddress(); + } else if (afi == 2) { + return normalizeIP(Inet6Address.getByName(addr), mask).getHostAddress(); + } else { + LOG.debug("The string {} is not a valid IP address!", addr); + return null; + } + } catch (Exception e){ + LOG.trace("Failed to normalize " + addr + ": " + ExceptionUtils.getStackTrace(e)); + } + return null; + } + + public static int getMaxMask(LispAFIAddress address) { + if (address instanceof Ipv4Address) { + return 32; + } + if (address instanceof Ipv6Address) { + return 128; + } + return -1; + } + + public static byte getMaxMaskForAfi(int afi) { + if (afi == 1) { + return (byte) 32; + } else if (afi == 2) { + return (byte) 128; + } else { + return (byte) -1; + } + } + + private static short getMaskForAfiAddress(LispAFIAddress addr) { + if (addr instanceof Ipv4Address) { + Short res = ((Ipv4Address) addr).getMask(); + return (res != null) ? res.shortValue() : 32; + } else if (addr instanceof Ipv6Address) { + Short res = ((Ipv6Address) addr).getMask(); + return (res != null) ? res.shortValue() : 128; + } else { + return 0; + } + } + + public static short getMaskForAddress(LispAddressContainer addr) { + if (addr.getAddress() instanceof Ipv4) { + Short res = ((Ipv4)addr.getAddress()).getIpv4Address().getMask(); + return (res != null) ? res.shortValue() : 32; + } else if (addr.getAddress() instanceof Ipv6) { + Short res = ((Ipv6)addr.getAddress()).getIpv6Address().getMask(); + return (res != null) ? res.shortValue() : 128; + } else if (addr.getAddress() instanceof LcafSegmentAddress) { + return getMaskForAfiAddress(LispAFIConvertor.toAFIfromPrimitive(((LcafSegmentAddress) addr.getAddress()) + .getAddress().getPrimitiveAddress())); + } + return 0; + } + + private static short getIpAfiForString(String addr) { + if(addr.matches("([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])\\.([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])\\.([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])\\.([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])") == true){ + return 1; + } + else if(addr.matches("([0-9a-f]+)\\:([0-9a-f]+)\\:([0-9a-f]+)\\:([0-9a-f]+)\\:([0-9a-f]+)\\:([0-9a-f]+)\\:([0-9a-f]+)\\:([0-9a-f]+)") == true){ + return 2; + } + return -1; + } + + public static LispAddressContainer setMask(LispAddressContainer addr, int mask) { + if (addr instanceof LispIpv4Address) { + return new LispAddressContainerBuilder().setAddress( + new Ipv4Builder().setIpv4Address( + new Ipv4AddressBuilder((LispIpv4Address) addr).setMask((short) mask).build()).build()) + .build(); + + } else if (addr instanceof LispIpv6Address) { + return new LispAddressContainerBuilder().setAddress( + new Ipv6Builder().setIpv6Address( + new Ipv6AddressBuilder((LispIpv6Address) addr).setMask((short) mask).build()).build()) + .build(); + } else if (addr instanceof LcafSegmentAddress) { + LispAddressContainer newAddr = setMask(LispAFIConvertor.toContainer(LispAFIConvertor.toAFIfromPrimitive(((LcafSegmentAddress) addr).getAddress().getPrimitiveAddress())), mask); + return new LispAddressContainerBuilder().setAddress(newAddr.getAddress()).build(); + } + return addr; + } + + public static LispAFIAddress setMask(LispAFIAddress addr, int mask) { + if (addr instanceof LispIpv4Address) { + return new Ipv4AddressBuilder().setIpv4Address(((LispIpv4Address) addr).getIpv4Address()) + .setAfi(addr.getAfi()).setMask((short)mask).build(); + } else if (addr instanceof LispIpv6Address) { + return new Ipv6AddressBuilder().setIpv6Address(((LispIpv6Address) addr).getIpv6Address()) + .setAfi(addr.getAfi()).setMask((short)mask).build(); + } else if (addr instanceof LcafSegmentAddress) { + LispAFIAddress afiAddr = LispAFIConvertor.toAFIfromPrimitive(((LcafSegmentAddress) addr).getAddress() + .getPrimitiveAddress()); + afiAddr = setMask(afiAddr, mask); + return new LcafSegmentAddrBuilder((LcafSegmentAddress) addr).setAddress( + new AddressBuilder().setPrimitiveAddress(LispAFIConvertor.toPrimitive(afiAddr)).build()).build(); + } + return addr; + } + + public static LispAFIAddress setMaskSourceDest(LispAFIAddress addr, int srcMask, int dstMask) { + DstAddress dst = LcafSourceDestHelper.getDstAddress(addr); + LispAFIAddress dstAfi = LispAFIConvertor.toAFIfromPrimitive(dst.getPrimitiveAddress()); + DstAddress newDst = new DstAddressBuilder(dst).setPrimitiveAddress(LispAFIConvertor.toPrimitive(setMask(dstAfi, dstMask))).build(); + SrcAddress src = LcafSourceDestHelper.getSrcAddress(addr); + LispAFIAddress srcAfi = LispAFIConvertor.toAFIfromPrimitive(src.getPrimitiveAddress()); + SrcAddress newSrc = new SrcAddressBuilder(src).setPrimitiveAddress(LispAFIConvertor.toPrimitive(setMask(srcAfi, srcMask))).build(); + return new LcafSourceDestAddrBuilder((LcafSourceDestAddress)addr).setDstAddress(newDst).setSrcAddress(newSrc).build(); + } + + public static LispAddressContainer setMaskSourceDest(LispAddressContainer addr, int srcMask, int dstMask) { + return new LispAddressContainerBuilder().setAddress( + new LcafSourceDestBuilder((LcafSourceDest) addr.getAddress()).setLcafSourceDestAddr( + (LcafSourceDestAddr) setMaskSourceDest( + ((LcafSourceDest) addr.getAddress()).getLcafSourceDestAddr(), srcMask, dstMask)) + .build()).build(); + } +} diff --git a/mappingservice/lisp-proto/src/main/yang/lisp-proto.yang b/mappingservice/lisp-proto/src/main/yang/lisp-proto.yang index ac7cdf244..87dfad637 100644 --- a/mappingservice/lisp-proto/src/main/yang/lisp-proto.yang +++ b/mappingservice/lisp-proto/src/main/yang/lisp-proto.yang @@ -58,6 +58,9 @@ module lisp-proto { type inet:ipv4-address; reference "https://tools.ietf.org/html/rfc3209#section-4.6.2.1"; } + leaf mask { + type uint8; + } } grouping LispIpv6Address { @@ -69,6 +72,9 @@ module lisp-proto { leaf Ipv6Address { type inet:ipv6-address; } + leaf mask { + type uint8; + } } grouping LispMacAddress { diff --git a/mappingservice/lisp-proto/src/test/java/org/opendaylight/lispflowmapping/serializer/MapNotifySerializationTest.java b/mappingservice/lisp-proto/src/test/java/org/opendaylight/lispflowmapping/serializer/MapNotifySerializationTest.java index 1becff672..a7cb6eedf 100644 --- a/mappingservice/lisp-proto/src/test/java/org/opendaylight/lispflowmapping/serializer/MapNotifySerializationTest.java +++ b/mappingservice/lisp-proto/src/test/java/org/opendaylight/lispflowmapping/serializer/MapNotifySerializationTest.java @@ -208,9 +208,9 @@ public class MapNotifySerializationTest extends BaseTestCase { )); assertEquals(4, mn.getEidToLocatorRecord().size()); - assertEquals(LispAFIConvertor.toContainer(LispAFIConvertor.asIPAfiAddress("153.16.254.1")), mn.getEidToLocatorRecord().get(0) + assertEquals(LispAFIConvertor.asIPv4Address("153.16.254.1"), mn.getEidToLocatorRecord().get(0) .getLispAddressContainer()); - assertEquals(LispAFIConvertor.toContainer(LispAFIConvertor.asIPAfiAddress("151.16.254.1")), mn.getEidToLocatorRecord().get(2) + assertEquals(LispAFIConvertor.asIPv4Address("151.16.254.1"), mn.getEidToLocatorRecord().get(2) .getLispAddressContainer()); assertEquals(LispAFIConvertor.toContainer(LispAFIConvertor.asIPAfiAddress("192.168.136.11")), mn.getEidToLocatorRecord().get(1) .getLocatorRecord().get(0).getLispAddressContainer()); diff --git a/mappingservice/lisp-proto/src/test/java/org/opendaylight/lispflowmapping/serializer/MapRegisterSerializationTest.java b/mappingservice/lisp-proto/src/test/java/org/opendaylight/lispflowmapping/serializer/MapRegisterSerializationTest.java index 01ecc0944..a098b60cb 100644 --- a/mappingservice/lisp-proto/src/test/java/org/opendaylight/lispflowmapping/serializer/MapRegisterSerializationTest.java +++ b/mappingservice/lisp-proto/src/test/java/org/opendaylight/lispflowmapping/serializer/MapRegisterSerializationTest.java @@ -246,9 +246,9 @@ public class MapRegisterSerializationTest extends BaseTestCase { )); assertEquals(4, mr.getEidToLocatorRecord().size()); - assertEquals(LispAFIConvertor.toContainer(LispAFIConvertor.asIPAfiAddress("153.16.254.1")), mr.getEidToLocatorRecord().get(0) + assertEquals(LispAFIConvertor.asIPv4Address("153.16.254.1"), mr.getEidToLocatorRecord().get(0) .getLispAddressContainer()); - assertEquals(LispAFIConvertor.toContainer(LispAFIConvertor.asIPAfiAddress("151.16.254.1")), mr.getEidToLocatorRecord().get(2) + assertEquals(LispAFIConvertor.asIPv4Address("151.16.254.1"), mr.getEidToLocatorRecord().get(2) .getLispAddressContainer()); assertEquals(LispAFIConvertor.toContainer(LispAFIConvertor.asIPAfiAddress("192.168.136.11")), mr.getEidToLocatorRecord().get(1) .getLocatorRecord().get(0).getLispAddressContainer()); diff --git a/mappingservice/lisp-proto/src/test/java/org/opendaylight/lispflowmapping/serializer/MapReplySerializationTest.java b/mappingservice/lisp-proto/src/test/java/org/opendaylight/lispflowmapping/serializer/MapReplySerializationTest.java index 78edee2b1..6cc107591 100644 --- a/mappingservice/lisp-proto/src/test/java/org/opendaylight/lispflowmapping/serializer/MapReplySerializationTest.java +++ b/mappingservice/lisp-proto/src/test/java/org/opendaylight/lispflowmapping/serializer/MapReplySerializationTest.java @@ -81,11 +81,11 @@ public class MapReplySerializationTest extends BaseTestCase { + "03 04 00 06 00 01 0a 0a " // + "0a 0a 04 03 02 01 00 01 " // + "00 02 00 01 00 02 00 03 " // - + "00 04 00 05 00 06 00 07 00 08 00 00 00 00 00 10 30 00 00 02 00 01 04 03 02 01")); + + "00 04 00 05 00 06 00 07 00 08 00 00 00 00 00 10 30 00 00 02 00 01 04 03 00 00")); assertEquals(2, mr.getNonce().longValue()); - assertEquals(LispAFIConvertor.toContainer(LispAFIConvertor.asIPAfiAddress(("1.2.3.4"))), mr.getEidToLocatorRecord().get(0) + assertEquals(LispAFIConvertor.asIPv4Address(("1.2.3.4")), mr.getEidToLocatorRecord().get(0) .getLispAddressContainer()); - assertEquals(LispAFIConvertor.toContainer(LispAFIConvertor.asIPAfiAddress(("4.3.2.1"))), mr.getEidToLocatorRecord().get(1) + assertEquals(LispAFIConvertor.asIPv4Prefix(("4.3.2.1"), 16), mr.getEidToLocatorRecord().get(1) .getLispAddressContainer()); assertEquals(false, mr.getEidToLocatorRecord().get(0).isAuthoritative()); assertEquals(true, mr.getEidToLocatorRecord().get(1).isAuthoritative()); @@ -145,10 +145,10 @@ public class MapReplySerializationTest extends BaseTestCase { public void deserialize__MultipleRecordsWithoutRLOCs() throws Exception { MapReply mr = MapReplySerializer.getInstance().deserialize(hexToByteBuffer("20 00 00 02 00 00 " // - + "00 00 00 00 00 00 00 00 00 01 00 20 00 00 00 00 00 01 01 02 03 04 00 00 00 00 00 10 30 00 00 02 00 01 04 03 02 01")); - assertEquals(LispAFIConvertor.toContainer(LispAFIConvertor.asIPAfiAddress(("1.2.3.4"))), mr.getEidToLocatorRecord().get(0) + + "00 00 00 00 00 00 00 00 00 01 00 20 00 00 00 00 00 01 01 02 03 04 00 00 00 00 00 10 30 00 00 02 00 01 04 03 00 00")); + assertEquals(LispAFIConvertor.asIPv4Address(("1.2.3.4")), mr.getEidToLocatorRecord().get(0) .getLispAddressContainer()); - assertEquals(LispAFIConvertor.toContainer(LispAFIConvertor.asIPAfiAddress(("4.3.2.1"))), mr.getEidToLocatorRecord().get(1) + assertEquals(LispAFIConvertor.asIPv4Prefix("4.3.2.1", 16), mr.getEidToLocatorRecord().get(1) .getLispAddressContainer()); assertEquals(false, mr.getEidToLocatorRecord().get(0).isAuthoritative()); assertEquals(true, mr.getEidToLocatorRecord().get(1).isAuthoritative()); diff --git a/mappingservice/lisp-proto/src/test/java/org/opendaylight/lispflowmapping/serializer/MapRequestSerializationTest.java b/mappingservice/lisp-proto/src/test/java/org/opendaylight/lispflowmapping/serializer/MapRequestSerializationTest.java index 577745fa1..072053ec9 100644 --- a/mappingservice/lisp-proto/src/test/java/org/opendaylight/lispflowmapping/serializer/MapRequestSerializationTest.java +++ b/mappingservice/lisp-proto/src/test/java/org/opendaylight/lispflowmapping/serializer/MapRequestSerializationTest.java @@ -172,7 +172,7 @@ public class MapRequestSerializationTest extends BaseTestCase { assertEquals(1, mr.getEidRecord().size()); EidRecord eid = mr.getEidRecord().get(0); assertEquals(0x20, eid.getMask().byteValue()); - assertEquals(LispAFIConvertor.toContainer(LispAFIConvertor.asIPAfiAddress("1.2.3.4")), eid.getLispAddressContainer()); + assertEquals(LispAFIConvertor.asIPv4Address("1.2.3.4"), eid.getLispAddressContainer()); } @Test @@ -192,9 +192,9 @@ public class MapRequestSerializationTest extends BaseTestCase { assertEquals(1, mr.getEidRecord().size()); EidRecord eid = mr.getEidRecord().get(0); assertEquals(0x20, eid.getMask().byteValue()); - assertEquals(LispAFIConvertor.toContainer(LispAFIConvertor.asIPAfiAddress("1.2.3.4")), eid.getLispAddressContainer()); + assertEquals(LispAFIConvertor.asIPv4Prefix("1.2.3.4", 0x20), eid.getLispAddressContainer()); MapReply mapReply = mr.getMapReply(); - assertEquals(LispAFIConvertor.toContainer(LispAFIConvertor.asIPAfiAddress(("1.2.3.4"))), mapReply.getLispAddressContainer()); + assertEquals(LispAFIConvertor.asIPv4Address(("1.2.3.4")), mapReply.getLispAddressContainer()); assertEquals(false, mapReply.isAuthoritative()); assertEquals(Action.NoAction, mapReply.getAction()); assertEquals(0, mapReply.getMapVersion().shortValue()); @@ -236,11 +236,11 @@ public class MapRequestSerializationTest extends BaseTestCase { EidRecord eid = mr.getEidRecord().get(0); assertEquals(0x0020, eid.getMask().shortValue()); - assertEquals(LispAFIConvertor.toContainer(LispAFIConvertor.asIPAfiAddress("1.2.3.4")), eid.getLispAddressContainer()); + assertEquals(LispAFIConvertor.asIPv4Address("1.2.3.4"), eid.getLispAddressContainer()); eid = mr.getEidRecord().get(1); assertEquals(0x0080, eid.getMask().shortValue()); - assertEquals(LispAFIConvertor.toContainer(LispAFIConvertor.asIPv6AfiAddress("0:0:0:0:0:0:0:5")), eid.getLispAddressContainer()); + assertEquals(LispAFIConvertor.asIPv6Address("0:0:0:0:0:0:0:5"), eid.getLispAddressContainer()); } @Test diff --git a/mappingservice/lisp-proto/src/test/java/org/opendaylight/lispflowmapping/serializer/address/LispSourceDestLCAFAddressTest.java b/mappingservice/lisp-proto/src/test/java/org/opendaylight/lispflowmapping/serializer/address/LispSourceDestLCAFAddressTest.java index a207b8a4b..1d9c5a5d5 100644 --- a/mappingservice/lisp-proto/src/test/java/org/opendaylight/lispflowmapping/serializer/address/LispSourceDestLCAFAddressTest.java +++ b/mappingservice/lisp-proto/src/test/java/org/opendaylight/lispflowmapping/serializer/address/LispSourceDestLCAFAddressTest.java @@ -42,8 +42,8 @@ public class LispSourceDestLCAFAddressTest extends BaseTestCase { assertEquals((byte) 0x10, srcDestAddress.getSrcMaskLength().byteValue()); assertEquals((byte) 0x18, srcDestAddress.getDstMaskLength().byteValue()); - assertEquals(LispAFIConvertor.asPrimitiveIPAfiAddress("17.34.51.68"), srcDestAddress.getSrcAddress().getPrimitiveAddress()); - assertEquals(LispAFIConvertor.asPrimitiveIPAfiAddress("34.51.68.85"), srcDestAddress.getDstAddress().getPrimitiveAddress()); + assertEquals(LispAFIConvertor.asPrimitiveIPv4AfiPrefix("17.34.51.68", 16), srcDestAddress.getSrcAddress().getPrimitiveAddress()); + assertEquals(LispAFIConvertor.asPrimitiveIPv4AfiPrefix("34.51.68.85", 24), srcDestAddress.getDstAddress().getPrimitiveAddress()); assertEquals(LispCanonicalAddressFormatEnum.SOURCE_DEST.getLispCode(), srcDestAddress.getLcafType().byteValue()); } @@ -67,14 +67,14 @@ public class LispSourceDestLCAFAddressTest extends BaseTestCase { public void deserialize__Ipv6() throws Exception { LcafSourceDestAddress srcAddress = (LcafSourceDestAddress) LispAddressSerializer.getInstance().deserialize(hexToByteBuffer("40 03 00 00 " + // "0C 20 00 28 " + // - "00 00 CC DD " + // reserved + masks - "00 02 11 22 33 44 55 66 77 88 99 AA BB CC AA BB CC DD " + // AFI=2, - "00 02 44 33 22 11 88 77 66 55 99 AA BB CC AA BB CC DD")); // AFI=2, + "00 00 78 78 " + // reserved + masks + "00 02 11 22 33 44 55 66 77 88 99 AA BB CC AA BB CC 00 " + // AFI=2, + "00 02 44 33 22 11 88 77 66 55 99 AA BB CC AA BB CC 00")); // AFI=2, // IPv6 - assertEquals(LispAFIConvertor.toPrimitive(LispAFIConvertor.asIPv6AfiAddress("1122:3344:5566:7788:99aa:bbcc:aabb:ccdd")), srcAddress + assertEquals(LispAFIConvertor.toPrimitive(LispAFIConvertor.asIPv6AfiPrefix("1122:3344:5566:7788:99aa:bbcc:aabb:ccdd", 0x78)), srcAddress .getSrcAddress().getPrimitiveAddress()); - assertEquals(LispAFIConvertor.toPrimitive(LispAFIConvertor.asIPv6AfiAddress("4433:2211:8877:6655:99aa:bbcc:aabb:ccdd")), srcAddress + assertEquals(LispAFIConvertor.toPrimitive(LispAFIConvertor.asIPv6AfiPrefix("4433:2211:8877:6655:99aa:bbcc:aabb:ccdd", 0x78)), srcAddress .getDstAddress().getPrimitiveAddress()); } diff --git a/mappingservice/southbound/src/test/java/org/opendaylight/lispflowmapping/southbound/lisp/LispSouthboundServiceTest.java b/mappingservice/southbound/src/test/java/org/opendaylight/lispflowmapping/southbound/lisp/LispSouthboundServiceTest.java index f0d1aaf96..fee28ef8b 100644 --- a/mappingservice/southbound/src/test/java/org/opendaylight/lispflowmapping/southbound/lisp/LispSouthboundServiceTest.java +++ b/mappingservice/southbound/src/test/java/org/opendaylight/lispflowmapping/southbound/lisp/LispSouthboundServiceTest.java @@ -128,7 +128,7 @@ public class LispSouthboundServiceTest extends BaseTestCase { mapReplyBuilder.setSecurityEnabled(true); eidToLocatorBuilder = new EidToLocatorRecordBuilder(); String ip = "0.0.0.0"; - eidToLocatorBuilder.setLispAddressContainer(getIPContainer(ip)); + eidToLocatorBuilder.setLispAddressContainer(LispAFIConvertor.asIPv4Prefix(ip, 0)); eidToLocatorBuilder.setLocatorRecord(new ArrayList()); eidToLocatorBuilder.setRecordTtl(10); eidToLocatorBuilder.setMapVersion((short) 0); @@ -164,18 +164,6 @@ public class LispSouthboundServiceTest extends BaseTestCase { mapNotifyBuilder.setAuthenticationData(new byte[0]); } - private LispAddressContainer getIPContainer(String ip) { - return LispAFIConvertor.toContainer(getIP(ip)); - } - - private org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev150820.lispaddress.lispaddresscontainer.address.ipv4.Ipv4Address getIP(String ip) { - return new Ipv4AddressBuilder().setIpv4Address(new Ipv4Address(ip)).setAfi((short) 1).build(); - } - - private org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev150820.lispaddress.lispaddresscontainer.address.ipv6.Ipv6Address getIPV6(String ip) { - return new Ipv6AddressBuilder().setIpv6Address(new Ipv6Address(ip)).setAfi((short) 2).build(); - } - @Test @Ignore public void todos() throws Exception { @@ -247,8 +235,8 @@ public class LispSouthboundServiceTest extends BaseTestCase { assertEquals(1, eidRecords.size()); EidToLocatorRecord eidRecord = eidRecords.get(0); assertEquals(2, eidRecord.getLocatorRecord().size()); - assertEquals(getIPContainer("10.1.0.110"), eidRecord.getLocatorRecord().get(0).getLispAddressContainer()); - assertEquals(getIPContainer("192.168.136.51"), eidRecord.getLocatorRecord().get(1).getLispAddressContainer()); + assertEquals(LispAFIConvertor.toContainer(LispAFIConvertor.asIPAfiAddress("10.1.0.110")), eidRecord.getLocatorRecord().get(0).getLispAddressContainer()); + assertEquals(LispAFIConvertor.toContainer(LispAFIConvertor.asIPAfiAddress("192.168.136.51")), eidRecord.getLocatorRecord().get(1).getLispAddressContainer()); } @Test @@ -279,11 +267,11 @@ public class LispSouthboundServiceTest extends BaseTestCase { handleMapRegisterPacket(mapRegisterPacket); EidToLocatorRecord eidToLocatorRecord = lastMapRegister().getEidToLocatorRecord().get(0); - assertEquals(getIPV6("2610:d0:ffff:192:0:0:0:1"), LispAFIConvertor.toAFI(eidToLocatorRecord.getLispAddressContainer())); + assertEquals(LispAFIConvertor.asIPv6Address("2610:d0:ffff:192:0:0:0:1"), eidToLocatorRecord.getLispAddressContainer()); assertEquals(AddressFamilyNumberEnum.IP6, AddressFamilyNumberEnum.valueOf(LispAFIConvertor.toAFI(eidToLocatorRecord.getLispAddressContainer()).getAfi())); - assertEquals(getIP("10.0.58.156"), LispAFIConvertor.toAFI(eidToLocatorRecord.getLocatorRecord().get(0).getLispAddressContainer())); + assertEquals(LispAFIConvertor.asIPAfiAddress("10.0.58.156"), LispAFIConvertor.toAFI(eidToLocatorRecord.getLocatorRecord().get(0).getLispAddressContainer())); } @Test @@ -292,10 +280,10 @@ public class LispSouthboundServiceTest extends BaseTestCase { handleMapRegisterPacket(mapRegisterPacket); EidToLocatorRecord eidToLocator = lastMapRegister().getEidToLocatorRecord().get(0); - assertEquals(getIP("153.16.254.1"), LispAFIConvertor.toAFI(eidToLocator.getLispAddressContainer())); + assertEquals(LispAFIConvertor.asIPv4Address("153.16.254.1"), eidToLocator.getLispAddressContainer()); assertEquals(1, eidToLocator.getLocatorRecord().size()); - assertEquals(getIP("192.168.136.10"), LispAFIConvertor.toAFI(eidToLocator.getLocatorRecord().get(0).getLispAddressContainer())); + assertEquals(LispAFIConvertor.asIPAfiAddress("192.168.136.10"), LispAFIConvertor.toAFI(eidToLocator.getLocatorRecord().get(0).getLispAddressContainer())); } @Test @@ -428,9 +416,9 @@ public class LispSouthboundServiceTest extends BaseTestCase { handleMapRequestAsByteArray(mapRequestPacket); List eids = lastMapRequest().getEidRecord(); assertEquals(1, eids.size()); - LispAFIAddress lispAddress = LispAFIConvertor.toAFI(eids.get(0).getLispAddressContainer()); - assertTrue(lispAddress instanceof org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev150820.lispaddress.lispaddresscontainer.address.ipv4.Ipv4Address); - assertEquals(getIP("1.2.3.4"), ((org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev150820.lispaddress.lispaddresscontainer.address.ipv4.Ipv4Address) lispAddress)); + LispAddressContainer lispAddress = eids.get(0).getLispAddressContainer(); + assertTrue(LispAFIConvertor.toAFI(lispAddress) instanceof org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev150820.lispaddress.lispaddresscontainer.address.ipv4.Ipv4Address); + assertEquals(LispAFIConvertor.asIPv4Address("1.2.3.4"), lispAddress); assertEquals((byte) 0x20, eids.get(0).getMask().byteValue()); assertEquals(0x3d8d2acd39c8d608L, lastMapRequest().getNonce().longValue()); // assertEquals(AddressFamilyNumberEnum.RESERVED, @@ -468,8 +456,8 @@ public class LispSouthboundServiceTest extends BaseTestCase { // ret(mapReply); handleMapRequestAsByteArray(mapRequestPacket); - assertEquals(getIPV6("2610:d0:ffff:192:0:0:0:1"), LispAFIConvertor.toAFI(lastMapRequest().getSourceEid().getLispAddressContainer())); - assertEquals(getIPV6("2610:d0:ffff:192:0:0:0:2"), LispAFIConvertor.toAFI(lastMapRequest().getEidRecord().get(0).getLispAddressContainer())); + assertEquals(LispAFIConvertor.asIPv6AfiAddress("2610:d0:ffff:192:0:0:0:1"), LispAFIConvertor.toAFI(lastMapRequest().getSourceEid().getLispAddressContainer())); + assertEquals(LispAFIConvertor.asIPv6Address("2610:d0:ffff:192:0:0:0:2"), lastMapRequest().getEidRecord().get(0).getLispAddressContainer()); } @Ignore @@ -525,7 +513,7 @@ public class LispSouthboundServiceTest extends BaseTestCase { @Test @Ignore public void mapReply__VerifyBasicIPv4Fields() throws Exception { - eidToLocatorBuilder.setMaskLength((short) 0x20).setLispAddressContainer(LispAFIConvertor.toContainer(getIP("10.0.20.200"))); + eidToLocatorBuilder.setMaskLength((short) 0x20).setLispAddressContainer(LispAFIConvertor.toContainer(LispAFIConvertor.asIPAfiAddress("10.0.20.200"))); mapReplyBuilder.setNonce(0x3d8d2acd39c8d608L); stubHandleRequest(); @@ -549,7 +537,7 @@ public class LispSouthboundServiceTest extends BaseTestCase { @Test @Ignore public void mapReply__VerifyBasicIPv6() throws Exception { - eidToLocatorBuilder.setMaskLength((short) 0x80).setLispAddressContainer(LispAFIConvertor.toContainer(getIPV6("0:0:0:0:0:0:0:1"))); + eidToLocatorBuilder.setMaskLength((short) 0x80).setLispAddressContainer(LispAFIConvertor.toContainer(LispAFIConvertor.asIPv6AfiAddress("0:0:0:0:0:0:0:1"))); stubHandleRequest(); @@ -570,9 +558,9 @@ public class LispSouthboundServiceTest extends BaseTestCase { @Test @Ignore public void mapReply__VerifyIPv6EidAndLocator() throws Exception { - eidToLocatorBuilder.setLispAddressContainer(LispAFIConvertor.toContainer(getIPV6("0:0:0:0:0:0:0:1"))); + eidToLocatorBuilder.setLispAddressContainer(LispAFIConvertor.toContainer(LispAFIConvertor.asIPv6AfiAddress("0:0:0:0:0:0:0:1"))); eidToLocatorBuilder.getLocatorRecord().add( - new LocatorRecordBuilder().setLispAddressContainer(LispAFIConvertor.toContainer(getIPV6("0:0:0:0:0:0:0:2"))).build()); + new LocatorRecordBuilder().setLispAddressContainer(LispAFIConvertor.toContainer(LispAFIConvertor.asIPv6AfiAddress("0:0:0:0:0:0:0:2"))).build()); stubHandleRequest(); @@ -598,9 +586,9 @@ public class LispSouthboundServiceTest extends BaseTestCase { @Test @Ignore public void mapReply__WithNonRoutableSingleLocator() throws Exception { - eidToLocatorBuilder.setMaskLength((short) 0x20).setLispAddressContainer(LispAFIConvertor.toContainer(getIP("10.0.20.200"))); + eidToLocatorBuilder.setMaskLength((short) 0x20).setLispAddressContainer(LispAFIConvertor.toContainer(LispAFIConvertor.asIPAfiAddress("10.0.20.200"))); eidToLocatorBuilder.getLocatorRecord().add( - new LocatorRecordBuilder().setRouted(false).setLispAddressContainer(LispAFIConvertor.toContainer(getIP("4.3.2.1"))).build()); + new LocatorRecordBuilder().setRouted(false).setLispAddressContainer(LispAFIConvertor.toContainer(LispAFIConvertor.asIPAfiAddress("4.3.2.1"))).build()); stubHandleRequest(); byte[] result = handleMapRequestAsByteArray(mapRequestPacket); @@ -611,9 +599,9 @@ public class LispSouthboundServiceTest extends BaseTestCase { @Ignore public void mapReply__WithSingleLocator() throws Exception { eidToLocatorBuilder.setMaskLength((short) 0x20)// - .setLispAddressContainer(LispAFIConvertor.toContainer(getIP("10.0.20.200"))); + .setLispAddressContainer(LispAFIConvertor.toContainer(LispAFIConvertor.asIPAfiAddress("10.0.20.200"))); eidToLocatorBuilder.getLocatorRecord().add( - new LocatorRecordBuilder().setRouted(true).setLispAddressContainer(LispAFIConvertor.toContainer(getIP("4.3.2.1"))).build()); + new LocatorRecordBuilder().setRouted(true).setLispAddressContainer(LispAFIConvertor.toContainer(LispAFIConvertor.asIPAfiAddress("4.3.2.1"))).build()); stubHandleRequest(); byte[] result = handleMapRequestAsByteArray(mapRequestPacket); @@ -632,9 +620,9 @@ public class LispSouthboundServiceTest extends BaseTestCase { @Ignore public void mapReply__WithMultipleLocator() throws Exception { eidToLocatorBuilder.getLocatorRecord().add( - new LocatorRecordBuilder().setRouted(true).setLispAddressContainer(LispAFIConvertor.toContainer(getIP("4.3.2.1"))).build()); + new LocatorRecordBuilder().setRouted(true).setLispAddressContainer(LispAFIConvertor.toContainer(LispAFIConvertor.asIPAfiAddress("4.3.2.1"))).build()); eidToLocatorBuilder.getLocatorRecord().add( - new LocatorRecordBuilder().setRouted(true).setLispAddressContainer(LispAFIConvertor.toContainer(getIPV6("0:0:0:0:0:0:0:1"))).build()); + new LocatorRecordBuilder().setRouted(true).setLispAddressContainer(LispAFIConvertor.toContainer(LispAFIConvertor.asIPv6AfiAddress("0:0:0:0:0:0:0:1"))).build()); stubHandleRequest(); byte[] result = handleMapRequestAsByteArray(mapRequestPacket); -- 2.36.6