*/
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);
}
+++ /dev/null
-/*
- * Copyright (c) 2014 Contextream, Inc. and others. All rights reserved.
- *
- * This program and the accompanying materials are made available under the
- * terms of the Eclipse Public License v1.0 which accompanies this distribution,
- * and is available at http://www.eclipse.org/legal/epl-v10.html
- */
-
-package org.opendaylight.lispflowmapping.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();
-
-}
+++ /dev/null
-/*
- * Copyright (c) 2014 Contextream, Inc. and others. All rights reserved.
- *
- * This program and the accompanying materials are made available under the
- * terms of the Eclipse Public License v1.0 which accompanies this distribution,
- * and is available at http://www.eclipse.org/legal/epl-v10.html
- */
-package org.opendaylight.lispflowmapping.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<LocatorRecord> 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<LocatorRecord> 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 + "]";
- }
-
-}
--- /dev/null
+/*
+ * Copyright (c) 2015 Cisco Systems, Inc. All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v1.0 which accompanies this distribution,
+ * and is available at http://www.eclipse.org/legal/epl-v10.html
+ */
+
+package org.opendaylight.lispflowmapping.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";
+}
public MapNotify handleMapRegister(MapRegister mb);
public MapReply handleMapRequest(MapRequest mr);
- public void removeMapping(LispAddressContainer address, int maskLen);
+ public void removeMapping(LispAddressContainer address);
}
* 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);
* 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);
}
*/
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);
}
package org.opendaylight.lispflowmapping.clusterdao;
+import java.util.Date;
import java.util.EnumSet;
import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;
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;
}
}
+ // 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);
}
});
}
public void setTimeUnit(TimeUnit timeUnit) {
this.timeUnit = timeUnit;
}
+
+ @Override
+ public ILispDAO putNestedTable(Object key, String valueKey) {
+ // TODO Auto-generated method stub
+ return null;
+ }
}
<artifactId>mappingservice.api</artifactId>
<version>${project.version}</version>
</dependency>
- <dependency>
- <groupId>${project.groupId}</groupId>
- <artifactId>mappingservice.inmemorydb</artifactId>
- <version>${project.version}</version>
- </dependency>
<dependency>
<groupId>${project.groupId}</groupId>
<artifactId>mappingservice.lisp-proto</artifactId>
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;
RpcResultBuilder<Void> 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.";
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<Void> rpcResultBuilder;
Preconditions.checkNotNull(input, "get-key RPC input must be not null!");
LOG.trace("RPC received to get the following key: " + input.toString());
+ // XXX: to remove once RPC API has been updated to remove explicit mask
+ input = new GetKeyInputBuilder(input).setLispAddressContainer(
+ MaskUtil.setMask(input.getLispAddressContainer(), input.getMaskLength())).build();
+
RpcResultBuilder<GetKeyOutput> 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";
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<GetMappingOutput> rpcResultBuilder;
MapRequest request = MapServerMapResolverUtil.getMapRequest(input.getLispAddressContainer(),
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<Void> rpcResultBuilder;
dsbe.removeAuthenticationKey(RPCInputConvertorUtil.toAuthenticationKey(input));
Preconditions.checkNotNull(input, "remove-mapping RPC input must be not null!");
LOG.trace("RPC received to remove the following mapping: " + input.toString());
+ // XXX: to remove once RPC API has been updated to remove explicit mask
+ input = new RemoveMappingInputBuilder(input).setLispAddressContainer(
+ MaskUtil.setMask(input.getLispAddressContainer(), input.getMaskLength())).build();
+
RpcResultBuilder<Void> rpcResultBuilder;
dsbe.removeMapping(RPCInputConvertorUtil.toMapping(input));
Preconditions.checkNotNull(input, "update-key RPC input must be not null!");
LOG.trace("RPC received to update the following key: " + input.toString());
+ // XXX: to remove once RPC API has been updated to remove explicit mask
+ input = new UpdateKeyInputBuilder(input).setEid(
+ new EidBuilder(input.getEid()).setLispAddressContainer(
+ MaskUtil.setMask(input.getEid().getLispAddressContainer(), input.getEid()
+ .getMaskLength())).build()).build();
+
RpcResultBuilder<Void> 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.";
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<Void> rpcResultBuilder;
dsbe.updateMapping(RPCInputConvertorUtil.toMapping(input));
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;
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;
LOG.info("LISP (RFC6830) Mapping Service init finished");
}
- class LispIpv4AddressInMemoryConverter implements ILispTypeConverter<Ipv4Address, Integer> {
- }
-
- class LispIpv6AddressInMemoryConverter implements ILispTypeConverter<Ipv6Address, Integer> {
- }
-
- class MappingServiceKeyConvertor implements ILispTypeConverter<MappingKey, Integer> {
- }
-
- class MappingServiceNoMaskKeyConvertor implements ILispTypeConverter<MappingNoMaskKey, Integer> {
- }
-
public static LispMappingService getLispMappingService() {
return lfmService;
}
}
for (AuthenticationKey authKey : authKeys) {
- addAuthenticationKey(authKey.getLispAddressContainer(), authKey.getMaskLength(), authKey.getAuthkey());
+ addAuthenticationKey(authKey.getLispAddressContainer(), authKey.getAuthkey());
}
}
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;
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");
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) {
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());
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() {
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));
+++ /dev/null
-/*
- * Copyright (c) 2014 Contextream, Inc. and others. All rights reserved.
- *
- * This program and the accompanying materials are made available under the
- * terms of the Eclipse Public License v1.0 which accompanies this distribution,
- * and is available at http://www.eclipse.org/legal/epl-v10.html
- */
-package org.opendaylight.lispflowmapping.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();
- }
-
-}
+++ /dev/null
-/*
- * Copyright (c) 2014 Contextream, Inc. and others. All rights reserved.
- *
- * This program and the accompanying materials are made available under the
- * terms of the Eclipse Public License v1.0 which accompanies this distribution,
- * and is available at http://www.eclipse.org/legal/epl-v10.html
- */
-package org.opendaylight.lispflowmapping.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);
- }
-}
+++ /dev/null
-/*
- * Copyright (c) 2014 Contextream, Inc. and others. All rights reserved.
- *
- * This program and the accompanying materials are made available under the
- * terms of the Eclipse Public License v1.0 which accompanies this distribution,
- * and is available at http://www.eclipse.org/legal/epl-v10.html
- */
-package org.opendaylight.lispflowmapping.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();
- }
-
-}
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;
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;
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);
builder.setSecurityEnabled(false);
builder.setNonce(request.getNonce());
builder.setEidToLocatorRecord(new ArrayList<EidToLocatorRecord>());
- for (EidRecord eid : request.getEidRecord()) {
- EidToLocatorRecordBuilder recordBuilder = new EidToLocatorRecordBuilder();
- Entry<IMappingKey, List<RLOCGroup>> 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<LocatorRecord>());
- List<RLOCGroup> 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<ItrRloc> 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<SubscriberRLOC> subscribers = DAOMappingUtil.getSubscribers(mapping.getKey().getEID(),
- mapping.getKey().getMask(), dao);
+ Set<SubscriberRLOC> subscribers = TopologyMapCache.getSubscribers(mapping.getLispAddressContainer(), dao);
if (subscribers == null) {
subscribers = Sets.newConcurrentHashSet();
} else if (subscribers.contains(subscriberRloc)) {
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 {
callback.handleMapReply(builder.build());
}
- private void addLocatorGroups(EidToLocatorRecordBuilder recordBuilder, List<RLOCGroup> rlocs,
- List<ItrRloc> itrRlocs) {
- for (RLOCGroup rloc : rlocs) {
- addLocators(recordBuilder, rloc, itrRlocs);
- recordBuilder.setRecordTtl(rloc.getTtl());
- }
- }
-
- private void addLocators(EidToLocatorRecordBuilder recordBuilder, RLOCGroup locatorObject,
- List<ItrRloc> 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<ItrRloc> itrRlocs) {
+ List<LocatorRecord> locatorRecords = recordBuilder.getLocatorRecord();
+ recordBuilder.setLocatorRecord(new ArrayList<LocatorRecord>());
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
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;
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<SubscriberRLOC> 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<SubscriberRLOC> 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<SubscriberRLOC> subscribers = DAOMappingUtil.getSubscribers(address, maskLen, dao);
+ TopologyMapCache.removeMapping(address, dao, shouldOverwrite());
+ Set<SubscriberRLOC> 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());
}
}
// 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()).
}
}
}
- DAOMappingUtil.addSubscribers(record.getLispAddressContainer(), record.getMaskLength(), subscribers, dao);
+ TopologyMapCache.addSubscribers(record.getLispAddressContainer(), subscribers, dao);
}
public boolean shouldOverwrite() {
}
@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);
}
}
--- /dev/null
+/*
+ * Copyright (c) 2014 Contextream, Inc. and others. All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v1.0 which accompanies this distribution,
+ * and is available at http://www.eclipse.org/legal/epl-v10.html
+ */
+
+package org.opendaylight.lispflowmapping.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<String, ?> 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<String, ?> entry = dao.get(key);
+ if (entry != null) {
+ return entry;
+ }
+ }
+ return null;
+ } else {
+ Map<String, ?> 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<String, ?> 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<String, ?> 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<String, ?> 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<String>(SubKeys.PASSWORD, key));
+ } else {
+ dao.put(address, new MappingEntry<String>(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<SubscriberRLOC> subscribers,
+ ILispDAO dao) {
+ if (eid.getAddress() instanceof LcafSourceDest) {
+ ILispDAO srcDstDao = getOrInstantiateSDInnerDao(eid, dao);
+ srcDstDao.put(LcafSourceDestHelper.getSrc(eid), new MappingEntry<Set<SubscriberRLOC>>(
+ SubKeys.SUBSCRIBERS, subscribers));
+ } else {
+ dao.put(eid, new MappingEntry<Set<SubscriberRLOC>>(SubKeys.SUBSCRIBERS, subscribers));
+ }
+ }
+
+ @SuppressWarnings("unchecked")
+ public static Set<SubscriberRLOC> 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<SubscriberRLOC>) 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);
+ }
+}
LOG.trace("Key: {}", entry.getKey());
LOG.trace("Value: {}", authkey);
- msmr.addAuthenticationKey(authkey.getLispAddressContainer(),
- authkey.getMaskLength(), authkey.getAuthkey());
+ msmr.addAuthenticationKey(authkey.getLispAddressContainer(), authkey.getAuthkey());
}
}
LOG.trace("Key: {}", entry.getKey());
LOG.trace("Value: {}", authkey);
- msmr.addAuthenticationKey(authkey.getLispAddressContainer(),
- authkey.getMaskLength(), authkey.getAuthkey());
+ msmr.addAuthenticationKey(authkey.getLispAddressContainer(), authkey.getAuthkey());
}
}
LOG.trace("Key: {}", entry);
LOG.trace("Value: {}", authkey);
- msmr.removeAuthenticationKey(authkey.getLispAddressContainer(), authkey.getMaskLength());
+ msmr.removeAuthenticationKey(authkey.getLispAddressContainer());
}
}
}
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<AuthenticationKey> 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<Mapping> 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<AuthenticationKey> 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<Mapping> 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<AuthenticationKey> 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<Mapping> 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");
}
LOG.trace("Key: {}", entry);
LOG.trace("Value: {}", dataObject);
- msmr.removeMapping(mapping.getLispAddressContainer(), mapping.getMaskLength());
+ msmr.removeMapping(mapping.getLispAddressContainer());
}
}
}
+++ /dev/null
-/*
- * Copyright (c) 2014 Contextream, Inc. and others. All rights reserved.
- *
- * This program and the accompanying materials are made available under the
- * terms of the Eclipse Public License v1.0 which accompanies this distribution,
- * and is available at http://www.eclipse.org/legal/epl-v10.html
- */
-
-package org.opendaylight.lispflowmapping.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<RLOCGroup> getLocatorsByEidRecord(EidRecord eid, ILispDAO dao, boolean iterateMask) {
- IMappingKey key = MappingKeyUtil.generateMappingKey(eid.getLispAddressContainer(), eid.getMask());
- return getLocators(key, dao, iterateMask);
- }
-
- public static Object getLocatorsSpecificByEidRecord(EidRecord eid, ILispDAO dao, String subkey,
- boolean iterateMask) {
- IMappingKey key = MappingKeyUtil.generateMappingKey(eid.getLispAddressContainer(), eid.getMask());
- return getLocatorsSpecific(key, dao, subkey, iterateMask);
- }
-
- public static List<RLOCGroup> getLocatorsByEidToLocatorRecord(EidToLocatorRecord eid, ILispDAO dao,
- boolean iterateMask) {
- IMappingKey key = MappingKeyUtil.generateMappingKey(eid.getLispAddressContainer(), eid.getMaskLength());
- return getLocators(key, dao, iterateMask);
- }
-
- public static Object getLocatorsSpecificByEidtoLocatorRecord(EidToLocatorRecord eid, ILispDAO dao, String subkey,
- boolean iterateMask) {
- IMappingKey key = MappingKeyUtil.generateMappingKey(eid.getLispAddressContainer(), eid.getMaskLength());
- return getLocatorsSpecific(key, dao, subkey, iterateMask);
- }
-
- public static List<RLOCGroup> getLocators(IMappingKey key, ILispDAO dao, boolean iterateMask) {
- Map<String, ?> locators = dao.get(key);
- List<RLOCGroup> result = aggregateLocators(locators);
- LispAFIAddress eid = LispAFIConvertor.toAFI(key.getEID());
- if (iterateMask && result.isEmpty() && MaskUtil.isMaskable(eid)) {
- result = findMaskLocators(dao, key);
- }
- return result;
- }
-
- private static List<RLOCGroup> aggregateLocators(Map<String, ?> locators) {
- List<RLOCGroup> result = new ArrayList<RLOCGroup>();
- 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<RLOCGroup> 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<String, ?> locators = dao.get(key);
- if (locators != null) {
- List<RLOCGroup> result = aggregateLocators(locators);
- if (result != null && !result.isEmpty()) {
- return result;
- }
- }
- }
- return null;
- }
-
- public static Entry<IMappingKey, List<RLOCGroup>> getMapping(LispAFIAddress srcEid, EidRecord eidRecord,
- ILispDAO dao) {
- // a map-request for an actual SrcDst LCAF, ignore src eid
- if (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<IMappingKey, List<RLOCGroup>> mapping = getMapping(srcEid,
- LispAFIConvertor.toAFI(eidRecord.getLispAddressContainer()), (short) MaskUtil.getMaxMask(srcEid),
- eidRecord.getMask(), dao);
-
- // if indeed SrcDst LCAF change the key to matched dst eid
- if (mapping.getKey().getEID().getAddress() instanceof LcafSourceDest) {
- LcafSourceDestAddr srcDst = ((LcafSourceDest) mapping.getKey().getEID().getAddress())
- .getLcafSourceDestAddr();
- IMappingKey newKey = MappingKeyUtil.generateMappingKey(
- LispAFIConvertor.toAFIfromPrimitive(srcDst.getDstAddress().getPrimitiveAddress()),
- srcDst.getDstMaskLength());
- return new AbstractMap.SimpleImmutableEntry<>(newKey, mapping.getValue());
- }
-
- return mapping;
- }
-
- public static Entry<IMappingKey, List<RLOCGroup>> getMapping(LispAFIAddress srcEid, LispAFIAddress dstEid,
- short srcMask, short dstMask, ILispDAO dao) {
- IMappingKey key = MappingKeyUtil.generateMappingKey(dstEid, dstMask);
- Entry<IMappingKey, Map<String, ?>> daoEntry = getDaoEntry(key, dao);
- if (daoEntry != null) {
- // try SrcDst eid lookup
- ILispDAO srcDstDao = (ILispDAO) daoEntry.getValue().get(DAOSubKeys.LCAF_SRCDST_SUBKEY.toString());
- if (srcDstDao != null) {
- Entry<IMappingKey, List<RLOCGroup>> mapping = getMappingForEid(srcEid, srcMask, srcDstDao);
- // if lookup fails, return whatever is found for dst eid
- if (mapping.getValue() != null) {
- LispAFIAddress newDst = LispAFIConvertor.toAFI(daoEntry.getKey().getEID());
- LispAFIAddress newSrc = LispAFIConvertor.toAFI(mapping.getKey().getEID());
-
- LispAFIAddress newEid = new LcafSourceDestAddrBuilder()
- .setDstAddress(
- new DstAddressBuilder().setPrimitiveAddress(LispAFIConvertor.toPrimitive(newDst))
- .build())
- .setSrcAddress(
- new SrcAddressBuilder().setPrimitiveAddress(LispAFIConvertor.toPrimitive(newSrc))
- .build()).setDstMaskLength((short) daoEntry.getKey().getMask())
- .setSrcMaskLength((short) mapping.getKey().getMask()).setAfi((short) 16387)
- .setLcafType((short) 12).build();
- 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<IMappingKey, List<RLOCGroup>> getMappingExact(LispAFIAddress srcEid, LispAFIAddress dstEid,
- short srcMask, short dstMask, ILispDAO dao) {
- IMappingKey dstKey = MappingKeyUtil.generateMappingKey(dstEid, dstMask);
- Map<String, ?> daoEntry = dao.get(dstKey);
- if (daoEntry != null) {
- // try SrcDst eid lookup
- ILispDAO srcDstDao = (ILispDAO) daoEntry.get(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<String, ?> mapping = srcDstDao.get(srcKey);
- LispAFIAddress newEid = new LcafSourceDestAddrBuilder()
- .setDstAddress(
- new DstAddressBuilder().setPrimitiveAddress(LispAFIConvertor.toPrimitive(dstEid))
- .build())
- .setSrcAddress(
- new SrcAddressBuilder().setPrimitiveAddress(LispAFIConvertor.toPrimitive(srcEid))
- .build()).setDstMaskLength((short) dstMask).setSrcMaskLength((short) srcMask)
- .setAfi((short) 16387).setLcafType((short) 12).build();
- 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<IMappingKey, List<RLOCGroup>> getMappingForEidRecord(EidRecord eid, ILispDAO dao) {
- return getMappingForEid(LispAFIConvertor.toAFI(eid.getLispAddressContainer()), eid.getMask(), dao);
- }
-
- private static Entry<IMappingKey, List<RLOCGroup>> makeMappingEntry(IMappingKey key, Map<String, ?> locators) {
- if (locators != null) {
- List<RLOCGroup> locatorsList = aggregateLocators(locators);
- if (locatorsList != null && !locatorsList.isEmpty()) {
- return new AbstractMap.SimpleImmutableEntry<>(key, locatorsList);
- }
- }
- return new AbstractMap.SimpleImmutableEntry<>(key, null);
- }
-
- public static Entry<IMappingKey, List<RLOCGroup>> getMappingForEid(LispAFIAddress eid, int maskLen, ILispDAO dao) {
- if (eid instanceof LcafSourceDestAddr) {
- LispAFIAddress srcAddr = LispAFIConvertor.toAFIfromPrimitive(((LcafSourceDestAddr) eid).getSrcAddress()
- .getPrimitiveAddress());
- LispAFIAddress dstAddr = LispAFIConvertor.toAFIfromPrimitive(((LcafSourceDestAddr) eid).getDstAddress()
- .getPrimitiveAddress());
-
- return getMapping(srcAddr, dstAddr, ((LcafSourceDestAddr) eid).getSrcMaskLength(),
- ((LcafSourceDestAddr) eid).getDstMaskLength(), dao);
- }
- IMappingKey key = MappingKeyUtil.generateMappingKey(eid, maskLen);
- Entry<IMappingKey, Map<String, ?>> entry = getDaoEntry(key, dao);
- if (entry == null) {
- return makeMappingEntry(key, null);
- } else {
- return makeMappingEntry(entry.getKey(), entry.getValue());
- }
- }
-
- public static Entry<IMappingKey, Map<String, ?>> 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<String, ?> entry = dao.get(key);
- if (entry != null) {
- return new AbstractMap.SimpleImmutableEntry<IMappingKey, Map<String, ?>>(key, entry);
- }
- }
- return null;
- } else {
- Map<String, ?> entry = dao.get(lookupKey);
- if (entry != null) {
- return new AbstractMap.SimpleImmutableEntry<IMappingKey, Map<String, ?>>(lookupKey,
- dao.get(lookupKey));
- } else {
- return null;
- }
- }
- }
-
- public static void addSubscribers(LispAddressContainer eid, int mask, Set<SubscriberRLOC> subscribers,
- ILispDAO dao) {
- IMappingKey key = MappingKeyUtil.generateMappingKey(eid, mask);
- dao.put(key, new MappingEntry<Set<SubscriberRLOC>>(DAOSubKeys.SUBSCRIBERS_SUBKEY.toString(), subscribers));
- }
-
- public static void addAuthenticationKey(LispAddressContainer address, int maskLen, String key, ILispDAO dao) {
- IMappingKey mappingServiceKey = MappingKeyUtil.generateMappingKey(address, maskLen);
- if (address.getAddress() instanceof LcafSourceDest) {
- IMappingKey srcKey = MappingKeyUtil.generateMappingKey(getSrcForLcafSrcDst(address),
- getSrcMaskForLcafSrcDst(address));
- ILispDAO srcDstDao = getOrInstantiateSrcDstInnerDao(address, maskLen, dao);
- srcDstDao.put(srcKey, new MappingEntry<String>(DAOSubKeys.PASSWORD_SUBKEY.toString(), key));
- } else {
- dao.put(mappingServiceKey, new MappingEntry<String>(DAOSubKeys.PASSWORD_SUBKEY.toString(), key));
- }
- }
-
- public static String getPasswordForMaskable(LispAddressContainer prefix, int maskLength, ILispDAO db,
- boolean shouldIterate) {
- while (maskLength >= 0) {
- IMappingKey key = MappingKeyUtil.generateMappingKey(prefix, maskLength);
- Object password = db.getSpecific(key, DAOSubKeys.PASSWORD_SUBKEY.toString());
- if (password != null && password instanceof String) {
- return (String) password;
- } else if (shouldIterate) {
- maskLength -= 1;
- } else {
- LOG.warn("Failed to find password!");
- return null;
- }
- }
- return null;
- }
-
- public static String getPassword(LispAddressContainer prefix, int maskLength, ILispDAO dao, boolean iterate) {
- if (MaskUtil.isMaskable(LispAFIConvertor.toAFI(prefix))) {
- return getPasswordForMaskable(prefix, maskLength, dao, iterate);
- } else if (prefix.getAddress() instanceof LcafSourceDest) {
- ILispDAO srcDstDao = getSrcDstInnerDao(prefix, maskLength, dao);
- if (srcDstDao != null) {
- return getPasswordForMaskable(LispAFIConvertor.toContainer(getSrcForLcafSrcDst(prefix)),
- getSrcMaskForLcafSrcDst(prefix), srcDstDao, iterate);
- }
- return null;
- } else {
- IMappingKey key = MappingKeyUtil.generateMappingKey(prefix, maskLength);
- Object password = dao.getSpecific(key, DAOSubKeys.PASSWORD_SUBKEY.toString());
- if (password != null && password instanceof String) {
- return (String) password;
- } else {
- LOG.warn("Failed to find password!");
- return null;
- }
- }
- }
-
- @SuppressWarnings("unchecked")
- public static Set<SubscriberRLOC> getSubscribers(LispAddressContainer prefix, int maskLength, ILispDAO dao) {
- Object subscribers;
- if (prefix.getAddress() instanceof LcafSourceDest) {
- IMappingKey srcKey = MappingKeyUtil.generateMappingKey(getSrcForLcafSrcDst(prefix),
- getSrcMaskForLcafSrcDst(prefix));
- ILispDAO srcDstDao = getSrcDstInnerDao(prefix, maskLength, dao);
- subscribers = srcDstDao.getSpecific(srcKey, DAOSubKeys.SUBSCRIBERS_SUBKEY.toString());
- } else {
- IMappingKey key = MappingKeyUtil.generateMappingKey(prefix, maskLength);
- subscribers = dao.getSpecific(key, DAOSubKeys.SUBSCRIBERS_SUBKEY.toString());
- }
-
- if (subscribers != null && subscribers instanceof Set<?>) {
- return (Set<SubscriberRLOC>) subscribers;
- }
- return null;
- }
-
- // SrcDst LCAFs are stored in a 2-tier DAO with dst having priority over
- // src. This method returns the DAO
- // associated to a dst or creates it if it doesn't exist.
- public static ILispDAO getOrInstantiateSrcDstInnerDao(LispAddressContainer address, int maskLen, ILispDAO dao) {
- IMappingKey dstKey = MappingKeyUtil.generateMappingKey(getDstForLcafSrcDst(address),
- getDstMaskForLcafSrcDst(address));
- ILispDAO srcDstDao = (ILispDAO) dao.getSpecific(dstKey, DAOSubKeys.LCAF_SRCDST_SUBKEY.toString());
- if (srcDstDao == null) {
- srcDstDao = new HashMapDb();
- dao.put(dstKey, new MappingEntry<>(DAOSubKeys.LCAF_SRCDST_SUBKEY.toString(), srcDstDao));
- }
- return srcDstDao;
- }
-
- // SrcDst LCAFs are stored in a 2-tier DAO with dst having priority over
- // src. This method returns the DAO
- // associated to a dst or null if it doesn't exist.
- public static ILispDAO getSrcDstInnerDao(LispAddressContainer address, int maskLen, ILispDAO dao) {
- IMappingKey dstKey = MappingKeyUtil.generateMappingKey(getDstForLcafSrcDst(address),
- getDstMaskForLcafSrcDst(address));
- return (ILispDAO) dao.getSpecific(dstKey, DAOSubKeys.LCAF_SRCDST_SUBKEY.toString());
- }
-
- public static boolean saveRlocs(EidToLocatorRecord eidRecord, boolean checkForChanges, ILispDAO dao,
- boolean shouldIterate, boolean shouldOverwrite) {
- Map<String, RLOCGroup> rlocGroups = new HashMap<String, RLOCGroup>();
- if (eidRecord.getLocatorRecord() != null) {
- for (LocatorRecord locatorRecord : eidRecord.getLocatorRecord()) {
- String subkey = getAddressKey(locatorRecord.getLispAddressContainer().getAddress(), shouldOverwrite);
- if (!rlocGroups.containsKey(subkey)) {
- rlocGroups
- .put(subkey,
- new RLOCGroup(eidRecord.getRecordTtl(), eidRecord.getAction(), eidRecord
- .isAuthoritative()));
- }
- rlocGroups.get(subkey).addRecord(locatorRecord);
- }
- } else {
- rlocGroups.put(DAOSubKeys.ADDRESS_SUBKEY.toString(),
- new RLOCGroup(eidRecord.getRecordTtl(), eidRecord.getAction(), eidRecord.isAuthoritative()));
- }
- List<MappingEntry<RLOCGroup>> entries = new ArrayList<>();
- for (String subkey : rlocGroups.keySet()) {
- entries.add(new MappingEntry<>(subkey, rlocGroups.get(subkey)));
- }
-
- if (eidRecord.getLispAddressContainer().getAddress() instanceof LcafSourceDest) {
- Entry<IMappingKey, List<RLOCGroup>> oldMapping = null, newMapping = null;
- LispAFIAddress srcAddr = getSrcForLcafSrcDst(eidRecord.getLispAddressContainer());
- LispAFIAddress dstAddr = getDstForLcafSrcDst(eidRecord.getLispAddressContainer());
- short srcMask = getSrcMaskForLcafSrcDst(eidRecord.getLispAddressContainer());
- short dstMask = getDstMaskForLcafSrcDst(eidRecord.getLispAddressContainer());
-
- if (checkForChanges) {
- oldMapping = DAOMappingUtil.getMappingExact(srcAddr, dstAddr, srcMask, dstMask, dao);
- }
- IMappingKey dstKey = MappingKeyUtil.generateMappingKey(dstAddr, dstMask);
- ILispDAO srcDstDao = (ILispDAO) dao.getSpecific(dstKey, DAOSubKeys.LCAF_SRCDST_SUBKEY.toString());
- if (srcDstDao == null) {
- srcDstDao = new HashMapDb();
- dao.put(dstKey, new MappingEntry<>(DAOSubKeys.LCAF_SRCDST_SUBKEY.toString(), srcDstDao));
- }
- IMappingKey srcKey = MappingKeyUtil.generateMappingKey(srcAddr, srcMask);
- srcDstDao.put(srcKey, entries.toArray(new MappingEntry[entries.size()]));
- if (checkForChanges) {
- newMapping = DAOMappingUtil.getMappingExact(srcAddr, dstAddr, srcMask, dstMask, dao);
- return (newMapping.getValue() == null) ? oldMapping.getValue() != null : !newMapping.getValue()
- .equals(oldMapping.getValue());
- }
- } else {
- List<RLOCGroup> oldLocators = null, newLocators = null;
- if (checkForChanges) {
- oldLocators = DAOMappingUtil.getLocatorsByEidToLocatorRecord(eidRecord, dao, shouldIterate);
- }
- IMappingKey key = MappingKeyUtil.generateMappingKey(eidRecord.getLispAddressContainer(),
- eidRecord.getMaskLength());
- dao.put(key, entries.toArray(new MappingEntry[entries.size()]));
- if (checkForChanges) {
- newLocators = DAOMappingUtil.getLocatorsByEidToLocatorRecord(eidRecord, dao, shouldIterate);
- return (newLocators == null) ? oldLocators != null : !newLocators.equals(oldLocators);
- }
- }
- return false;
- }
-
- public static String getAddressKey(Address address, boolean shouldOverwrite) {
- if (address instanceof LcafKeyValue) {
- LcafKeyValue keyVal = (LcafKeyValue) address;
- if (keyVal.getLcafKeyValueAddressAddr().getKey().getPrimitiveAddress() instanceof DistinguishedName) {
- return ((DistinguishedName) keyVal.getLcafKeyValueAddressAddr().getKey().getPrimitiveAddress())
- .getDistinguishedNameAddress().getDistinguishedName();
- }
- }
- if (shouldOverwrite) {
- return DAOSubKeys.ADDRESS_SUBKEY.toString();
- } else {
- return String.valueOf(address.hashCode());
- }
- }
-
- public static void removeAuthenticationKey(LispAddressContainer address, int maskLen, ILispDAO dao) {
- if (address.getAddress() instanceof LcafSourceDest) {
- ILispDAO srcDstDao = getSrcDstInnerDao(address, maskLen, dao);
- if (srcDstDao != null) {
- IMappingKey srcKey = MappingKeyUtil.generateMappingKey(getSrcForLcafSrcDst(address),
- getSrcMaskForLcafSrcDst(address));
- srcDstDao.removeSpecific(srcKey, DAOSubKeys.PASSWORD_SUBKEY.toString());
- }
- } else {
- IMappingKey key = MappingKeyUtil.generateMappingKey(address, maskLen);
- dao.removeSpecific(key, DAOSubKeys.PASSWORD_SUBKEY.toString());
- }
- }
-
- private static void removeMappingRlocs(Entry<IMappingKey, List<RLOCGroup>> mapping, ILispDAO db,
- boolean shouldOverwrite) {
- if (mapping == null || mapping.getValue() == null) {
- return;
- }
- for (RLOCGroup group : mapping.getValue()) {
- for (LocatorRecord record : group.getRecords()) {
- db.removeSpecific(mapping.getKey(),
- DAOMappingUtil.getAddressKey(record.getLispAddressContainer().getAddress(), shouldOverwrite));
- }
- }
- }
-
- public static void removeMapping(LispAddressContainer address, int maskLen, ILispDAO dao, boolean oerwrite) {
- Entry<IMappingKey, List<RLOCGroup>> mapping;
- ILispDAO db;
- if (address.getAddress() instanceof LcafSourceDest) {
- db = getSrcDstInnerDao(address, maskLen, dao);
- LispAFIAddress srcAddr = getSrcForLcafSrcDst(address);
- short srcMask = getSrcMaskForLcafSrcDst(address);
- mapping = DAOMappingUtil.getMappingForEid(srcAddr, srcMask, db);
- } else {
- db = dao;
- mapping = DAOMappingUtil.getMappingForEid(LispAFIConvertor.toAFI(address), maskLen, db);
- }
- removeMappingRlocs(mapping, db, oerwrite);
- }
-
- public static void removeSubscribers(LispAddressContainer address, int maskLen, ILispDAO dao,
- boolean shouldOverwrite) {
- Entry<IMappingKey, List<RLOCGroup>> mapping;
- ILispDAO db;
- if (address.getAddress() instanceof LcafSourceDest) {
- db = getSrcDstInnerDao(address, maskLen, dao);
- LispAFIAddress srcAddr = getSrcForLcafSrcDst(address);
- short srcMask = getSrcMaskForLcafSrcDst(address);
- mapping = DAOMappingUtil.getMappingForEid(srcAddr, srcMask, db);
- } else {
- db = dao;
- mapping = DAOMappingUtil.getMappingForEid(LispAFIConvertor.toAFI(address), maskLen, db);
- }
- db.removeSpecific(mapping.getKey(), DAOSubKeys.SUBSCRIBERS_SUBKEY.toString());
- }
-
- public static void removeEntry(LispAddressContainer address, int maskLen, ILispDAO dao, boolean shouldOverwrite) {
- Entry<IMappingKey, List<RLOCGroup>> mapping;
- ILispDAO db;
- if (address.getAddress() instanceof LcafSourceDest) {
- db = getSrcDstInnerDao(address, maskLen, dao);
- LispAFIAddress srcAddr = getSrcForLcafSrcDst(address);
- short srcMask = getSrcMaskForLcafSrcDst(address);
- mapping = DAOMappingUtil.getMappingForEid(srcAddr, srcMask, db);
- } else {
- db = dao;
- mapping = DAOMappingUtil.getMappingForEid(LispAFIConvertor.toAFI(address), maskLen, db);
- }
-
- db.remove(mapping.getKey());
- }
-
- public static LispAFIAddress getSrcForLcafSrcDst(LispAddressContainer container) {
- return LispAFIConvertor.toAFIfromPrimitive(((LcafSourceDest) container.getAddress()).getLcafSourceDestAddr()
- .getSrcAddress().getPrimitiveAddress());
- }
-
- public static LispAFIAddress getDstForLcafSrcDst(LispAddressContainer container) {
- return LispAFIConvertor.toAFIfromPrimitive(((LcafSourceDest) container.getAddress()).getLcafSourceDestAddr()
- .getDstAddress().getPrimitiveAddress());
- }
-
- public static short getSrcMaskForLcafSrcDst(LispAddressContainer container) {
- return ((LcafSourceDest) container.getAddress()).getLcafSourceDestAddr().getSrcMaskLength();
- }
-
- public static short getDstMaskForLcafSrcDst(LispAddressContainer container) {
- return ((LcafSourceDest) container.getAddress()).getLcafSourceDestAddr().getDstMaskLength();
- }
-
-}
+++ /dev/null
-/*
- * Copyright (c) 2015 Cisco Systems, Inc. All rights reserved.
- *
- * This program and the accompanying materials are made available under the
- * terms of the Eclipse Public License v1.0 which accompanies this distribution,
- * and is available at http://www.eclipse.org/legal/epl-v10.html
- */
-
-package org.opendaylight.lispflowmapping.implementation.util;
-
-/**
- * Defines DAO Subkeys
- *
- * @author Florin Coras
- *
- */
-public enum DAOSubKeys {
- PASSWORD_SUBKEY("password"),
- ADDRESS_SUBKEY("address"),
- SUBSCRIBERS_SUBKEY("subscribers"),
- LCAF_SRCDST_SUBKEY("lcaf_srcdst"),
- UNKOWN("-1");
-
- private String key;
-
- private DAOSubKeys(String key) {
- this.key = key;
- }
-
- public String getKey() {
- return key;
- }
-
- @Override
- public String toString() {
- return key;
- }
-
-}
*
*/
public class InstanceIdentifierUtil {
- public static InstanceIdentifier<AuthenticationKey> createAuthenticationKeyIid(LispAddressContainer eid, int mask) {
+ public static InstanceIdentifier<AuthenticationKey> 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<Mapping> createMappingIid(LispAddressContainer eid, int mask, MappingOrigin orig) {
+ public static InstanceIdentifier<Mapping> 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);
}
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);
}
}
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());
+++ /dev/null
-/*
- * Copyright (c) 2014 Contextream, Inc. and others. All rights reserved.
- *
- * This program and the accompanying materials are made available under the
- * terms of the Eclipse Public License v1.0 which accompanies this distribution,
- * and is available at http://www.eclipse.org/legal/epl-v10.html
- */
-package org.opendaylight.lispflowmapping.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;
- }
- }
-}
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());
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());
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();
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());
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());
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());
import java.util.ArrayList;
import java.util.HashMap;
-import java.util.List;
import java.util.Map;
import org.jmock.api.Invocation;
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;
private ILispDAO lispDAO;
private MapRequestBuilder mapRequest;
- private LispAFIAddress v4Address;
- private LispAFIAddress v6Address;
+ private LispAddressContainer v4Address;
+ private LispAddressContainer v6Address;
- private HashMap<IMappingKey, Map<String, RLOCGroup>> daoResults;
+ private HashMap<LispAddressContainer, Map<String, EidToLocatorRecord>> daoResults;
@Override
@Before
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<IMappingKey, Map<String, RLOCGroup>>();
+ v4Address = LispAFIConvertor.asIPv4Address("1.2.3.4");
+ v6Address = LispAFIConvertor.asIPv6Address("0:0:0:0:0:0:0:1");
+ daoResults = new HashMap<LispAddressContainer, Map<String, EidToLocatorRecord>>();
}
@Test
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);
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());
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());
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();
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")));
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());
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<String, List<RLOCGroup>> result = new HashMap<String, List<RLOCGroup>>();
- result.put(DAOSubKeys.ADDRESS_SUBKEY.toString(), new ArrayList<RLOCGroup>());
+ Map<String, EidToLocatorRecord> result = new HashMap<String, EidToLocatorRecord>();
+ result.put(SubKeys.RECORD, null);
MapReply mapReply = getNativelyForwardMapReply(mr, result);
assertEquals(Action.NativelyForward, eidToLocators.getAction());
}
- private MapReply getNativelyForwardMapReply(MapRequest mr, Map<String, List<RLOCGroup>> result) {
- allowing(lispDAO).get(wany(IMappingKey.class));
+ private MapReply getNativelyForwardMapReply(MapRequest mr, Map<String, EidToLocatorRecord> 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;
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;
}
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());
MapReply mapReply = testedMapResolver.handleMapRequest(mr);
EidToLocatorRecord eidToLocators = mapReply.getEidToLocatorRecord().get(0);
- assertEquals(0, eidToLocators.getLocatorRecord().size());
-
+ assertEquals(null, eidToLocators.getLocatorRecord());
}
@Test
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());
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
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();
record1.getLocatorRecord().add(locator1.build());
EidToLocatorRecordBuilder record2 = getDefaultEidToLocatorBuilder();
- record2.setLispAddressContainer(LispAFIConvertor.toContainer(v6Address));
+ record2.setLispAddressContainer(v6Address);
record2.setMaskLength((short) 128);
record2.setRecordTtl(100);
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<String, RLOCGroup> prepareMapping(EidToLocatorRecord... records) {
+ private Map<String, EidToLocatorRecord> prepareMapping(EidToLocatorRecord... records) {
if (records.length > 0) {
for (EidToLocatorRecord eidToLocatorRecord : records) {
- Map<String, RLOCGroup> result = new HashMap<String, RLOCGroup>();
- RLOCGroup rlocs = new RLOCGroup(eidToLocatorRecord.getRecordTtl(), eidToLocatorRecord.getAction(),
- eidToLocatorRecord.isAuthoritative());
- for (LocatorRecord locator : eidToLocatorRecord.getLocatorRecord()) {
- rlocs.addRecord(locator);
- }
- result.put(DAOSubKeys.ADDRESS_SUBKEY.toString(), rlocs);
-
- daoResults.put(
- MappingKeyUtil.generateMappingKey(eidToLocatorRecord.getLispAddressContainer(),
- (short) eidToLocatorRecord.getMaskLength()), result);
+ Map<String, EidToLocatorRecord> result = new HashMap<String, EidToLocatorRecord>();
+ result.put(SubKeys.RECORD, eidToLocatorRecord);
+
+ daoResults.put(eidToLocatorRecord.getLispAddressContainer(), result);
}
}
- ValueSaverAction<IMappingKey> daoGetSaverAction = new ValueSaverAction<IMappingKey>() {
+ ValueSaverAction<LispAddressContainer> daoGetSaverAction = new ValueSaverAction<LispAddressContainer>() {
@Override
- protected boolean validate(IMappingKey value) {
+ protected boolean validate(LispAddressContainer value) {
return true;
}
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() {
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;
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;
private LispMappingService testedMapServer;
private ILispDAO lispDAO;
private MapRegisterBuilder mapRegisterBuilder;
- private LispAFIAddress eid;
- private LispAFIAddress rloc;
+ private LispAddressContainer eid;
+ private LispAddressContainer rloc;
private ValueSaverAction<MappingEntry<?>[]> mappingEntriesSaver;
private MapRegister mapRegisterWithAuthentication;
+ private String eidIpv4String = "10.31.0.5";
+ private String eidIpv6String = "1:1:1:1:1:1:1:0";
@Override
@Before
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<LocatorRecord>());
- 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<EidToLocatorRecord>());
mapRegisterBuilder.getEidToLocatorRecord().add(recordBuilder.build());
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
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());
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")));
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());
}
@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());
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());
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());
@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());
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());
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());
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());
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());
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());
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());
@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());
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());
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();
@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);
.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());
}
@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);
}
@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());
@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);
}
@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);
}
@Test
public void handleAddAuthenticationKey() throws Exception {
String password = "pass";
- IMappingKey key = getDefualtKey();
+ LispAddressContainer key = getDefaultKey();
oneOf(lispDAO).put(weq(key),
- weq((MappingEntry<String>[]) (Arrays.asList(new MappingEntry<String>(DAOSubKeys.PASSWORD_SUBKEY.toString(), password)).toArray())));
- testedMapServer.addAuthenticationKey(LispAFIConvertor.toContainer(eid), key.getMask(), password);
+ weq((MappingEntry<String>[]) (Arrays.asList(new MappingEntry<String>(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() {
package org.opendaylight.lispflowmapping.inmemorydb;
+import java.util.Date;
import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.ConcurrentMap;
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;
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);
}
});
}
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;
+ }
}
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;
@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
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);
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(
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");
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");
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);
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(
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
+ LOG.warn("Interrupted while sleeping");
}
mapRegisterPacketWithoutNotify[mapRegisterPacketWithoutNotify.length - 1] += 1;
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 ---------------------------
}
// 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);
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 {
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<EidRecord>());
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<ItrRloc>());
if (srcEid != null) {
mapRequestBuilder.setSourceEid(new SourceEidBuilder().setLispAddressContainer(LispAFIConvertor.
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());
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());
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
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);
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);
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();
/* 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();
}
}
builder.setMapVersion(buffer.getShort());
LispAFIAddress afiAddress = LispAddressSerializer.getInstance().deserialize(buffer);
+ afiAddress = SerializerHelper.fixMask(afiAddress, builder.getMaskLength());
LispAddressContainer container = LispAFIConvertor.toContainer(afiAddress);
builder.setLispAddressContainer(container);
--- /dev/null
+/*
+ * Copyright (c) 2015 Cisco Systems, Inc. All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v1.0 which accompanies this distribution,
+ * and is available at http://www.eclipse.org/legal/epl-v10.html
+ */
+
+package org.opendaylight.lispflowmapping.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;
+ }
+}
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;
@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());
--- /dev/null
+/*
+ * Copyright (c) 2015 Cisco Systems, Inc. All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v1.0 which accompanies this distribution,
+ * and is available at http://www.eclipse.org/legal/epl-v10.html
+ */
+
+package org.opendaylight.lispflowmapping.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;
+ }
+}
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()
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()
.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()
.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()
.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();
- }
}
}
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;
}
- 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) {
--- /dev/null
+/*
+ * Copyright (c) 2014 Contextream, Inc. and others. All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v1.0 which accompanies this distribution,
+ * and is available at http://www.eclipse.org/legal/epl-v10.html
+ */
+package org.opendaylight.lispflowmapping.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();
+ }
+}
type inet:ipv4-address;
reference "https://tools.ietf.org/html/rfc3209#section-4.6.2.1";
}
+ leaf mask {
+ type uint8;
+ }
}
grouping LispIpv6Address {
leaf Ipv6Address {
type inet:ipv6-address;
}
+ leaf mask {
+ type uint8;
+ }
}
grouping LispMacAddress {
));
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());
));
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());
+ "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());
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());
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
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());
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
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());
}
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());
}
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<LocatorRecord>());
eidToLocatorBuilder.setRecordTtl(10);
eidToLocatorBuilder.setMapVersion((short) 0);
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 {
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
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
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
handleMapRequestAsByteArray(mapRequestPacket);
List<EidRecord> 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,
// 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
@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();
@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();
@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();
@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);
@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);
@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);
Code Review / lispflowmapping.git / commitdiff