import java.nio.ByteBuffer;
import java.util.ArrayList;
import java.util.Arrays;
+import java.util.List;
import javax.inject.Inject;
+
+
+
+
+
//import org.codehaus.jettison.json.JSONException;
//import org.codehaus.jettison.json.JSONObject;
//import org.codehaus.jettison.json.JSONTokener;
import org.opendaylight.lispflowmapping.implementation.LispMappingService;
import org.opendaylight.lispflowmapping.interfaces.lisp.IFlowMapping;
import org.opendaylight.lispflowmapping.interfaces.mappingservice.IMappingService;
-import org.opendaylight.lispflowmapping.lisp.type.AddressFamilyNumberEnum;
-import org.opendaylight.lispflowmapping.lisp.type.LispCanonicalAddressFormatEnum;
-import org.opendaylight.lispflowmapping.lisp.util.LispAFIConvertor;
+import org.opendaylight.lispflowmapping.lisp.util.LispAddressStringifier;
+import org.opendaylight.lispflowmapping.lisp.util.LispAddressUtil;
import org.opendaylight.lispflowmapping.lisp.type.LispMessage;
import org.opendaylight.lispflowmapping.lisp.serializer.MapNotifySerializer;
import org.opendaylight.lispflowmapping.lisp.serializer.MapRegisterSerializer;
import org.opendaylight.lispflowmapping.lisp.serializer.MapRequestSerializer;
import org.opendaylight.lispflowmapping.type.sbplugin.IConfigLispSouthboundPlugin;
import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.AddMapping;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.EidToLocatorRecord.Action;
import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.GotMapNotify;
import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.GotMapReply;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.LcafApplicationDataAddress;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.LcafListAddress;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.LcafSegmentAddress;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.LcafTrafficEngineeringAddress;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.LispAFIAddress;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.LispIpv4Address;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.LispMacAddress;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.LispProtoListener;
import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.MapNotify;
import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.MapRegister;
import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.MapReply;
import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.MapRequest;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.ReencapHop;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.OdlLispProtoListener;
import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.RequestMapping;
import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.XtrReplyMapping;
import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.XtrRequestMapping;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.eidrecords.EidRecord;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.eidrecords.EidRecordBuilder;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.eidtolocatorrecords.EidToLocatorRecord;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.eidtolocatorrecords.EidToLocatorRecordBuilder;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.lcafkeyvalueaddress.KeyBuilder;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.lcafkeyvalueaddress.ValueBuilder;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.lcaflistaddress.Addresses;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.lcaflistaddress.AddressesBuilder;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.lcafsegmentaddress.AddressBuilder;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.lcafsourcedestaddress.DstAddressBuilder;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.lcafsourcedestaddress.SrcAddressBuilder;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.lcaftrafficengineeringaddress.Hops;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.lcaftrafficengineeringaddress.HopsBuilder;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.lispaddress.LispAddressContainer;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.lispaddress.lispaddresscontainer.address.LcafKeyValue;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.lispaddress.lispaddresscontainer.address.LcafSourceDest;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.lispaddress.lispaddresscontainer.address.ipv4.Ipv4Address;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.lispaddress.lispaddresscontainer.address.lcafapplicationdata.LcafApplicationDataAddr;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.lispaddress.lispaddresscontainer.address.lcafapplicationdata.LcafApplicationDataAddrBuilder;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.lispaddress.lispaddresscontainer.address.lcafkeyvalue.LcafKeyValueAddressAddrBuilder;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.lispaddress.lispaddresscontainer.address.lcaflist.LcafListAddrBuilder;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.lispaddress.lispaddresscontainer.address.lcafsegment.LcafSegmentAddrBuilder;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.lispaddress.lispaddresscontainer.address.lcafsourcedest.LcafSourceDestAddrBuilder;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.lispaddress.lispaddresscontainer.address.lcaftrafficengineering.LcafTrafficEngineeringAddrBuilder;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.lispaddress.lispaddresscontainer.address.no.NoAddressBuilder;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.eid.container.Eid;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.eid.container.EidBuilder;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.eid.list.EidItem;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.eid.list.EidItemBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.locatorrecords.LocatorRecord;
import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.locatorrecords.LocatorRecordBuilder;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.mapping.record.container.MappingRecord.Action;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.mapping.record.container.MappingRecordBuilder;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.mapping.record.list.MappingRecordItem;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.mapping.record.list.MappingRecordItemBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.mapregisternotification.MapRegisterBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.maprequest.ItrRloc;
import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.maprequest.ItrRlocBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.maprequest.SourceEidBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.maprequestnotification.MapRequestBuilder;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.reencaphop.Hop;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.reencaphop.HopBuilder;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.rloc.container.Rloc;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.rloc.container.RlocBuilder;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev100924.IpAddress;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev100924.IpPrefix;
+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.PortNumber;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.lisp.address.types.rev151105.AfiListLcaf;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.lisp.address.types.rev151105.ApplicationDataLcaf;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.lisp.address.types.rev151105.ExplicitLocatorPathLcaf;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.lisp.address.types.rev151105.InstanceIdType;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.lisp.address.types.rev151105.Ipv4PrefixAfi;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.lisp.address.types.rev151105.KeyValueAddressLcaf;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.lisp.address.types.rev151105.MacAfi;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.lisp.address.types.rev151105.SimpleAddress;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.lisp.address.types.rev151105.SourceDestKeyLcaf;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.lisp.address.types.rev151105.lisp.address.address.AfiList;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.lisp.address.types.rev151105.lisp.address.address.ApplicationData;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.lisp.address.types.rev151105.lisp.address.address.ExplicitLocatorPath;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.lisp.address.types.rev151105.lisp.address.address.Ipv4Prefix;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.lisp.address.types.rev151105.lisp.address.address.Ipv4PrefixBuilder;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.lisp.address.types.rev151105.lisp.address.address.KeyValueAddress;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.lisp.address.types.rev151105.lisp.address.address.Mac;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.lisp.address.types.rev151105.lisp.address.address.SourceDestKey;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.lisp.address.types.rev151105.lisp.address.address.afi.list.AfiListBuilder;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.lisp.address.types.rev151105.lisp.address.address.application.data.ApplicationDataBuilder;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.lisp.address.types.rev151105.lisp.address.address.explicit.locator.path.ExplicitLocatorPathBuilder;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.lisp.address.types.rev151105.lisp.address.address.explicit.locator.path.explicit.locator.path.Hop;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.lisp.address.types.rev151105.lisp.address.address.explicit.locator.path.explicit.locator.path.Hop.LrsBits;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.lisp.address.types.rev151105.lisp.address.address.explicit.locator.path.explicit.locator.path.HopBuilder;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.yang.types.rev100924.MacAddress;
import org.ops4j.pax.exam.Option;
import org.ops4j.pax.exam.junit.PaxExam;
import org.ops4j.pax.exam.util.Filter;
private byte[] mapRegisterPacketWithoutNotify;
String lispBindAddress = "127.0.0.1";
String ourAddress = "127.0.0.2";
- private LispAFIAddress locatorEid;
+ private Rloc locatorEid;
private DatagramSocket socket;
private byte[] mapRegisterPacketWithAuthenticationAndMapNotify;
@Before
public void before() throws Exception {
areWeReady();
- locatorEid = LispAFIConvertor.asIPAfiAddress("4.3.2.1");
+ locatorEid = LispAddressUtil.asIpv4Rloc("4.3.2.1");
socket = initSocket(socket, LispMessage.PORT_NUM);
// SRC: 127.0.0.1:58560 to 127.0.0.1:4342
//registerAndQuery__SrcDestLCAF();
//registerAndQuery__SrcDestLCAFOverlap();
//registerAndQuery__KeyValueLCAF();
- registerAndQuery__ListLCAF();
- registerAndQuery__ApplicationData();
- registerAndQuery__TrafficEngineering();
- registerAndQuery__SegmentLCAF();
+ //registerAndQuery__ListLCAF();
+ //registerAndQuery__ApplicationData();
+ //registerAndQuery__TrafficEngineering();
+ //registerAndQuery__SegmentLCAF();
}
@Test
public void mapRegisterWithMapNotifyAndMapRequest() throws SocketTimeoutException {
cleanUP();
- LispAFIAddress eid = LispAFIConvertor.toAFI(LispAFIConvertor.asIPv4Address("1.2.3.4"));
+ Eid eid = LispAddressUtil.asIpv4PrefixEid("1.2.3.4/32");
- MapReply mapReply = registerAddressAndQuery(eid, 32);
+ MapReply mapReply = registerAddressAndQuery(eid);
assertEquals(4, mapReply.getNonce().longValue());
- assertEquals(LispAFIConvertor.toContainer(locatorEid), mapReply.getEidToLocatorRecord().get(0).getLocatorRecord().get(0)
- .getLispAddressContainer());
+ assertEquals(locatorEid, mapReply.getMappingRecordItem().get(0).getMappingRecord().getLocatorRecord().get(0)
+ .getRloc());
}
cleanUP();
String macAddress = "01:02:03:04:05:06";
- MapReply reply = registerAddressAndQuery(LispAFIConvertor.asMacAfiAddress(macAddress));
+ MapReply reply = registerAddressAndQuery(LispAddressUtil.asMacEid(macAddress));
assertTrue(true);
- LispAFIAddress addressFromNetwork = LispAFIConvertor.toAFI(reply.getEidToLocatorRecord().get(0).getLispAddressContainer());
- assertTrue(addressFromNetwork instanceof LispMacAddress);
- String macAddressFromReply = ((org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.lispaddress.lispaddresscontainer.address.mac.MacAddress) addressFromNetwork).getMacAddress().getValue();
+ Eid addressFromNetwork = reply.getMappingRecordItem().get(0).getMappingRecord().getEid();
+ assertEquals(MacAfi.class, addressFromNetwork.getAddressType());
+ String macAddressFromReply = ((Mac) addressFromNetwork.getAddress()).getMac().getValue();
assertEquals(macAddress, macAddressFromReply);
}
public void mapRequestMapRegisterAndMapRequest() throws SocketTimeoutException {
cleanUP();
- LispAFIAddress eid = LispAFIConvertor.toAFI(LispAFIConvertor.asIPv4Address("1.2.3.4"));
+ Eid eid = LispAddressUtil.asIpv4PrefixEid("1.2.3.4/32");
MapRequestBuilder mapRequestBuilder = new MapRequestBuilder();
mapRequestBuilder.setNonce((long) 4);
- mapRequestBuilder.setSourceEid(new SourceEidBuilder().setLispAddressContainer(
- LispAFIConvertor.toContainer(new NoAddressBuilder().setAfi((short) 0).build())).build());
- mapRequestBuilder.setEidRecord(new ArrayList<EidRecord>());
- mapRequestBuilder.getEidRecord().add(
- new EidRecordBuilder().setMask((short) 32).setLispAddressContainer(LispAFIConvertor.toContainer(eid)).build());
+ mapRequestBuilder.setSourceEid(new SourceEidBuilder().setEid(LispAddressUtil.getNoAddressEid()).build());
+ mapRequestBuilder.setEidItem(new ArrayList<EidItem>());
+ mapRequestBuilder.getEidItem().add(new EidItemBuilder().setEid(eid).build());
mapRequestBuilder.setItrRloc(new ArrayList<ItrRloc>());
mapRequestBuilder.getItrRloc().add(
- new ItrRlocBuilder().setLispAddressContainer(LispAFIConvertor.toContainer(LispAFIConvertor.asIPAfiAddress(ourAddress))).build());
+ new ItrRlocBuilder().setRloc(LispAddressUtil.asIpv4Rloc(ourAddress)).build());
sendMapRequest(mapRequestBuilder.build());
MapReply mapReply = receiveMapReply();
assertEquals(4, mapReply.getNonce().longValue());
- assertEquals(0, mapReply.getEidToLocatorRecord().get(0).getLocatorRecord().size());
+ assertEquals(0, mapReply.getMappingRecordItem().get(0).getMappingRecord().getLocatorRecord().size());
MapRegisterBuilder mapRegisterbuilder = new MapRegisterBuilder();
mapRegisterbuilder.setWantMapNotify(true);
mapRegisterbuilder.setNonce((long) 8);
- EidToLocatorRecordBuilder etlrBuilder = new EidToLocatorRecordBuilder();
- etlrBuilder.setLispAddressContainer(LispAFIConvertor.toContainer(eid));
- etlrBuilder.setMaskLength((short) 32);
+ MappingRecordBuilder etlrBuilder = new MappingRecordBuilder();
+ etlrBuilder.setEid(eid);
etlrBuilder.setRecordTtl(254);
LocatorRecordBuilder recordBuilder = new LocatorRecordBuilder();
- recordBuilder.setLispAddressContainer(LispAFIConvertor.toContainer(LispAFIConvertor.asIPAfiAddress("4.3.2.1")));
+ recordBuilder.setRloc(LispAddressUtil.asIpv4Rloc("4.3.2.1"));
etlrBuilder.setLocatorRecord(new ArrayList<LocatorRecord>());
etlrBuilder.getLocatorRecord().add(recordBuilder.build());
- mapRegisterbuilder.setEidToLocatorRecord(new ArrayList<EidToLocatorRecord>());
- mapRegisterbuilder.getEidToLocatorRecord().add(etlrBuilder.build());
+ mapRegisterbuilder.setMappingRecordItem(new ArrayList<MappingRecordItem>());
+ mapRegisterbuilder.getMappingRecordItem().add(
+ new MappingRecordItemBuilder().setMappingRecord(etlrBuilder.build()).build());
sendMapRegister(mapRegisterbuilder.build());
MapNotify mapNotify = receiveMapNotify();
assertEquals(8, mapNotify.getNonce().longValue());
sendMapRequest(mapRequestBuilder.build());
mapReply = receiveMapReply();
assertEquals(4, mapReply.getNonce().longValue());
- assertEquals(recordBuilder.getLispAddressContainer(), mapReply.getEidToLocatorRecord().get(0).getLocatorRecord().get(0)
- .getLispAddressContainer());
+ assertEquals(recordBuilder.getRloc(), mapReply.getMappingRecordItem().get(0).getMappingRecord()
+ .getLocatorRecord().get(0).getRloc());
}
public void testMapRegisterDosntOverwritesOtherSubKeys() throws SocketTimeoutException {
cleanUP();
- 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");
- LispAFIAddress rloc2 = LispAFIConvertor.asKeyValue("subkey2", LispAFIConvertor.toPrimitive(rloc2Value));
+ Eid eid = LispAddressUtil.asIpv4PrefixEid("1.2.3.4/32");
+ SimpleAddress rloc1Value = new SimpleAddress(new IpAddress(new Ipv4Address("4.3.2.1")));
+ Rloc rloc1 = LispAddressUtil.asKeyValueAddress("subkey1", rloc1Value);
+ SimpleAddress rloc2Value = new SimpleAddress(new IpAddress(new Ipv4Address("4.3.2.2")));
+ Rloc rloc2 = LispAddressUtil.asKeyValueAddress("subkey2", rloc2Value);
MapReply mapReply = sendMapRegisterTwiceWithDiffrentValues(eid, rloc1, rloc2);
- assertEquals(2, mapReply.getEidToLocatorRecord().get(0).getLocatorRecord().size());
- assertEquals(LispAFIConvertor.toContainer(rloc2), mapReply.getEidToLocatorRecord().get(0).getLocatorRecord().get(0).getLispAddressContainer());
- assertEquals(LispAFIConvertor.toContainer(rloc1), mapReply.getEidToLocatorRecord().get(0).getLocatorRecord().get(1).getLispAddressContainer());
+ assertEquals(2, mapReply.getMappingRecordItem().get(0).getMappingRecord().getLocatorRecord().size());
+ assertEquals(rloc2, mapReply.getMappingRecordItem().get(0).getMappingRecord().getLocatorRecord().get(0)
+ .getRloc());
+ assertEquals(rloc1, mapReply.getMappingRecordItem().get(0).getMappingRecord().getLocatorRecord().get(1)
+ .getRloc());
}
public void testMapRegisterOverwritesSameSubkey() throws SocketTimeoutException {
cleanUP();
- 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");
- LispAFIAddress rloc2 = LispAFIConvertor.asKeyValue("subkey", LispAFIConvertor.toPrimitive(rloc2Value));
+ Eid eid = LispAddressUtil.asIpv4PrefixEid("1.2.3.4/32");
+ SimpleAddress rloc1Value = new SimpleAddress(new IpAddress(new Ipv4Address("4.3.2.1")));
+ Rloc rloc1 = LispAddressUtil.asKeyValueAddress("subkey1", rloc1Value);
+ SimpleAddress rloc2Value = new SimpleAddress(new IpAddress(new Ipv4Address("4.3.2.2")));
+ Rloc rloc2 = LispAddressUtil.asKeyValueAddress("subkey2", rloc2Value);
MapReply mapReply = sendMapRegisterTwiceWithDiffrentValues(eid, rloc1, rloc2);
- assertEquals(1, mapReply.getEidToLocatorRecord().get(0).getLocatorRecord().size());
- assertEquals(LispAFIConvertor.toContainer(rloc2), mapReply.getEidToLocatorRecord().get(0).getLocatorRecord().get(0).getLispAddressContainer());
+ assertEquals(1, mapReply.getMappingRecordItem().get(0).getMappingRecord().getLocatorRecord().size());
+ assertEquals(rloc2, mapReply.getMappingRecordItem().get(0).getMappingRecord().getLocatorRecord().get(0)
+ .getRloc());
}
public void testMapRegisterOverwritesNoSubkey() throws SocketTimeoutException {
cleanUP();
mapService.setMappingOverwrite(true);
- 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");
+ Eid eid = LispAddressUtil.asIpv4PrefixEid("1.2.3.4/32");
+ Rloc rloc1Value = LispAddressUtil.asIpv4Rloc("4.3.2.1");
+ Rloc rloc2Value = LispAddressUtil.asIpv4Rloc("4.3.2.2");
MapReply mapReply = sendMapRegisterTwiceWithDiffrentValues(eid, rloc1Value, rloc2Value);
- assertEquals(1, mapReply.getEidToLocatorRecord().get(0).getLocatorRecord().size());
- assertEquals(LispAFIConvertor.toContainer(rloc2Value), mapReply.getEidToLocatorRecord().get(0).getLocatorRecord().get(0)
- .getLispAddressContainer());
+ assertEquals(1, mapReply.getMappingRecordItem().get(0).getMappingRecord().getLocatorRecord().size());
+ assertEquals(rloc2Value, mapReply.getMappingRecordItem().get(0).getMappingRecord().getLocatorRecord().get(0)
+ .getRloc());
}
public void testMapRegisterDoesntOverwritesNoSubkey() throws SocketTimeoutException {
cleanUP();
mapService.setMappingOverwrite(false);
- 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");
+ Eid eid = LispAddressUtil.asIpv4PrefixEid("1.2.3.4/32");
+ Rloc rloc1Value = LispAddressUtil.asIpv4Rloc("4.3.2.1");
+ Rloc rloc2Value = LispAddressUtil.asIpv4Rloc("4.3.2.2");
MapReply mapReply = sendMapRegisterTwiceWithDiffrentValues(eid, rloc1Value, rloc2Value);
- 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(
- rloc2ReturnValueContainer))
- || (LispAFIConvertor.toContainer(rloc1Value).equals(rloc2ReturnValueContainer) && LispAFIConvertor.toContainer(rloc2Value).equals(
- rloc1ReturnValueContainer)));
+ assertEquals(1, mapReply.getMappingRecordItem().get(0).getMappingRecord().getLocatorRecord().size());
+ Rloc rloc1ReturnValueContainer = mapReply.getMappingRecordItem().get(0).getMappingRecord().getLocatorRecord().get(0).getRloc();
+ Rloc rloc2ReturnValueContainer = mapReply.getMappingRecordItem().get(0).getMappingRecord().getLocatorRecord().get(1).getRloc();
+ assertTrue((rloc1Value.equals(rloc1ReturnValueContainer) && rloc2Value.equals(rloc2ReturnValueContainer))
+ || (rloc1Value.equals(rloc2ReturnValueContainer) && rloc2Value.equals(rloc1ReturnValueContainer)));
}
- private MapReply sendMapRegisterTwiceWithDiffrentValues(LispAFIAddress eid, LispAFIAddress rloc1, LispAFIAddress rloc2)
+ private MapReply sendMapRegisterTwiceWithDiffrentValues(Eid eid, Rloc rloc1, Rloc rloc2)
throws SocketTimeoutException {
MapRegister mb = createMapRegister(eid, rloc1);
MapNotify mapNotify = lms.handleMapRegister(mb);
MapRequest mr = createMapRequest(eid);
MapReply mapReply = lms.handleMapRequest(mr);
- assertEquals(mb.getEidToLocatorRecord().get(0).getLocatorRecord().get(0).getLispAddressContainer(), mapReply.getEidToLocatorRecord().get(0)
- .getLocatorRecord().get(0).getLispAddressContainer());
+ assertEquals(mb.getMappingRecordItem().get(0).getMappingRecord().getLocatorRecord().get(0).getRloc(), mapReply.getMappingRecordItem().get(0).getMappingRecord()
+ .getLocatorRecord().get(0).getRloc());
mb = createMapRegister(eid, rloc2);
mapNotify = lms.handleMapRegister(mb);
assertEquals(8, mapNotify.getNonce().longValue());
ByteBuffer readBuf = ByteBuffer.wrap(receivePacket().getData());
MapRequest smr = MapRequestSerializer.getInstance().deserialize(readBuf);
assertTrue(smr.isSmr());
- 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.asIPv4Address("1.2.3.4").equals(smrEid));
+ Eid sourceEid = smr.getSourceEid().getEid();
+ assertTrue(LispAddressUtil.asIpv4Eid("153.16.254.1").equals(sourceEid));
+ Eid smrEid = smr.getEidItem().get(0).getEid();
+ assertTrue(LispAddressUtil.asIpv4PrefixEid("1.2.3.4/32").equals(smrEid));
}
// --------------------- Northbound Tests ---------------------------
/*
private void northboundAddKey() throws Exception {
cleanUP();
- LispIpv4Address address = LispAFIConvertor.asIPAfiAddress("1.2.3.4");
+ LispIpv4Address address = LispAddressUtil.asIPAfiAddress("1.2.3.4");
int mask = 32;
String pass = "asdf";
String authKeyJSON = createAuthKeyJSON(pass, address, mask);
callURL("PUT", "application/json", "text/plain", authKeyJSON, url);
- String retrievedKey = lms.getAuthenticationKey(LispAFIConvertor.toContainer(address), mask);
+ String retrievedKey = lms.getAuthenticationKey(LispAddressUtil.toContainer(address), mask);
// Check stored password matches the one sent
assertEquals(pass, retrievedKey);
private void northboundRetrieveSourceDestKey() throws Exception {
cleanUP();
- org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.lispsimpleaddress.primitiveaddress.Ipv4 address1 = (org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev150820.lispsimpleaddress.primitiveaddress.Ipv4) LispAFIConvertor
- .toPrimitive(LispAFIConvertor.asIPAfiAddress("10.0.0.1"));
- org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.lispsimpleaddress.primitiveaddress.Ipv4 address2 = (org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev150820.lispsimpleaddress.primitiveaddress.Ipv4) LispAFIConvertor
- .toPrimitive(LispAFIConvertor.asIPAfiAddress("10.0.0.2"));
+ org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.lispsimpleaddress.primitiveaddress.Ipv4 address1 = (org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev150820.lispsimpleaddress.primitiveaddress.Ipv4) LispAddressUtil
+ .toPrimitive(LispAddressUtil.asIPAfiAddress("10.0.0.1"));
+ org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.lispsimpleaddress.primitiveaddress.Ipv4 address2 = (org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev150820.lispsimpleaddress.primitiveaddress.Ipv4) LispAddressUtil
+ .toPrimitive(LispAddressUtil.asIPAfiAddress("10.0.0.2"));
int mask1 = 32;
int mask2 = 32;
LcafSourceDestAddr sourceDestAddress = new LcafSourceDestAddrBuilder().setAfi(AddressFamilyNumberEnum.LCAF.getIanaCode())
.setDstAddress(new DstAddressBuilder().setPrimitiveAddress(address2).build()).setDstMaskLength((short) mask2).build();
String pass = "asdf";
- lms.addAuthenticationKey(LispAFIConvertor.toContainer(sourceDestAddress), mask1, pass);
+ lms.addAuthenticationKey(LispAddressUtil.toContainer(sourceDestAddress), mask1, pass);
// URL url = createGetKeyIPv4URL(address1, mask1);
URL url = createGetKeySourceDestURL(address1.getIpv4Address().getAfi(),
- ((LispIpv4Address) LispAFIConvertor.toAFIfromPrimitive(sourceDestAddress.getSrcAddress().getPrimitiveAddress())).getIpv4Address().getValue(), sourceDestAddress.getSrcMaskLength(),
- ((LispIpv4Address) LispAFIConvertor.toAFIfromPrimitive(sourceDestAddress.getDstAddress().getPrimitiveAddress())).getIpv4Address().getValue(), sourceDestAddress.getDstMaskLength());
+ ((LispIpv4Address) LispAddressUtil.toAFIfromPrimitive(sourceDestAddress.getSrcAddress().getPrimitiveAddress())).getIpv4Address().getValue(), sourceDestAddress.getSrcMaskLength(),
+ ((LispIpv4Address) LispAddressUtil.toAFIfromPrimitive(sourceDestAddress.getDstAddress().getPrimitiveAddress())).getIpv4Address().getValue(), sourceDestAddress.getDstMaskLength());
String reply = callURL("GET", null, "application/json", null, url);
JSONTokener jt = new JSONTokener(reply);
JSONObject json = new JSONObject(jt);
private void northboundRetrieveKey() throws Exception {
cleanUP();
- LispIpv4Address address = LispAFIConvertor.asIPAfiAddress("10.0.0.1");
+ LispIpv4Address address = LispAddressUtil.asIPAfiAddress("10.0.0.1");
int mask = 32;
String pass = "asdf";
- lms.addAuthenticationKey(LispAFIConvertor.toContainer(address), mask, pass);
+ lms.addAuthenticationKey(LispAddressUtil.toContainer(address), mask, pass);
URL url = createGetKeyIPv4URL(address, mask);
String reply = callURL("GET", null, "application/json", null, url);
private void northboundAddMapping() throws Exception {
cleanUP();
String pass = "asdf";
- LispIpv4Address eid = LispAFIConvertor.asIPAfiAddress("10.0.0.1");
+ LispIpv4Address eid = LispAddressUtil.asIPAfiAddress("10.0.0.1");
int mask = 32;
- LispIpv4Address rloc = LispAFIConvertor.asIPAfiAddress("20.0.0.2");
+ LispIpv4Address rloc = LispAddressUtil.asIPAfiAddress("20.0.0.2");
// NB add mapping always checks the key
- lms.addAuthenticationKey(LispAFIConvertor.toContainer(eid), mask, pass);
+ lms.addAuthenticationKey(LispAddressUtil.toContainer(eid), mask, pass);
URL url = createPutURL("mapping");
String mapRegisterJSON = createMapRegisterJSON(pass, eid, mask, rloc);
// Retrieve the RLOC from the database
MapRequestBuilder mapRequestBuilder = new MapRequestBuilder();
mapRequestBuilder.setPitr(false);
- mapRequestBuilder.setEidRecord(new ArrayList<EidRecord>());
- mapRequestBuilder.getEidRecord().add(
- new EidRecordBuilder().setMask((short) mask).setLispAddressContainer(LispAFIConvertor.toContainer(eid)).build());
+ mapRequestBuilder.setEidItem(new ArrayList<EidItem>());
+ mapRequestBuilder.getEidItem().add(
+ new EidRecordBuilder().setMask((short) mask).setLispAddressContainer(LispAddressUtil.toContainer(eid)).build());
MapReply mapReply = lms.handleMapRequest(mapRequestBuilder.build());
- LispIpv4Address retrievedRloc = (LispIpv4Address) LispAFIConvertor.toAFI(
- mapReply.getEidToLocatorRecord().get(0).getLocatorRecord().get(0).getLispAddressContainer());
+ LispIpv4Address retrievedRloc = (LispIpv4Address) LispAddressUtil.toAFI(
+ mapReply.getMappingRecordItem().get(0).getMappingRecord().getLocatorRecord().get(0).getLispAddressContainer());
assertEquals(rloc.getIpv4Address().getValue(), retrievedRloc.getIpv4Address().getValue());
private void northboundRetrieveMapping() throws Exception {
cleanUP();
- LispIpv4Address eid = LispAFIConvertor.asIPAfiAddress("10.0.0.1");
+ LispIpv4Address eid = LispAddressUtil.asIPAfiAddress("10.0.0.1");
int mask = 32;
- LispIpv4Address rloc = LispAFIConvertor.asIPAfiAddress("20.0.0.2");
+ LispIpv4Address rloc = LispAddressUtil.asIPAfiAddress("20.0.0.2");
// Insert mapping in the database
MapRegisterBuilder mapRegister = new MapRegisterBuilder();
EidToLocatorRecordBuilder etlr = new EidToLocatorRecordBuilder();
- etlr.setLispAddressContainer(LispAFIConvertor.toContainer(eid));
+ etlr.setLispAddressContainer(LispAddressUtil.toContainer(eid));
etlr.setMaskLength((short) mask);
etlr.setRecordTtl(254);
etlr.setAuthoritative(false);
etlr.setAction(Action.NoAction);
LocatorRecordBuilder record = new LocatorRecordBuilder();
- record.setLispAddressContainer(LispAFIConvertor.toContainer(rloc));
+ record.setLispAddressContainer(LispAddressUtil.toContainer(rloc));
record.setRouted(true);
record.setRlocProbed(false);
record.setLocalLocator(false);
record.setMulticastWeight((short) 1);
etlr.setLocatorRecord(new ArrayList<LocatorRecord>());
etlr.getLocatorRecord().add(record.build());
- mapRegister.setEidToLocatorRecord(new ArrayList<EidToLocatorRecord>());
- mapRegister.getEidToLocatorRecord().add(etlr.build());
+ mapRegister.setMappingRecordItem(new ArrayList<MappingRecordItem>());
+ mapRegister.getMappingRecordItem().add(new MappingRecordItemBuilder().setMappingRecord(etlr.build()).build());
lms.handleMapRegister(mapRegister.build(), false);
// Get mapping using NB interface. No IID used
private void northboundDeleteMapping() throws Exception {
cleanUP();
- LispIpv4Address eid = LispAFIConvertor.asIPAfiAddress("10.0.0.1");
+ LispIpv4Address eid = LispAddressUtil.asIPAfiAddress("10.0.0.1");
int mask = 32;
- LispIpv4Address rloc = LispAFIConvertor.asIPAfiAddress("20.0.0.2");
+ LispIpv4Address rloc = LispAddressUtil.asIPAfiAddress("20.0.0.2");
// Insert mapping in the database
MapRegisterBuilder mapRegister = new MapRegisterBuilder();
EidToLocatorRecordBuilder etlr = new EidToLocatorRecordBuilder();
- etlr.setLispAddressContainer(LispAFIConvertor.toContainer(eid));
+ etlr.setLispAddressContainer(LispAddressUtil.toContainer(eid));
etlr.setMaskLength((short) mask);
etlr.setRecordTtl(254);
etlr.setAuthoritative(false);
etlr.setAction(Action.NoAction);
LocatorRecordBuilder record = new LocatorRecordBuilder();
- record.setLispAddressContainer(LispAFIConvertor.toContainer(rloc));
+ record.setLispAddressContainer(LispAddressUtil.toContainer(rloc));
record.setRouted(true);
record.setRlocProbed(false);
record.setLocalLocator(false);
record.setMulticastWeight((short) 1);
etlr.setLocatorRecord(new ArrayList<LocatorRecord>());
etlr.getLocatorRecord().add(record.build());
- mapRegister.setEidToLocatorRecord(new ArrayList<EidToLocatorRecord>());
- mapRegister.getEidToLocatorRecord().add(etlr.build());
+ mapRegister.setMappingRecordItem(new ArrayList<MappingRecordItem>());
+ mapRegister.getMappingRecordItem().add(new MappingRecordItemBuilder().setMappingRecord(etlr.build()).build());
lms.handleMapRegister(mapRegister.build(), false);
// Delete mapping using NB interface. No IID used
private void northboundRetrieveSourceDestMapping() throws Exception {
cleanUP();
- org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.lispsimpleaddress.primitiveaddress.Ipv4 address1 = (org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev150820.lispsimpleaddress.primitiveaddress.Ipv4) LispAFIConvertor
- .toPrimitive(LispAFIConvertor.asIPAfiAddress("10.0.0.1"));
- org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.lispsimpleaddress.primitiveaddress.Ipv4 address2 = (org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev150820.lispsimpleaddress.primitiveaddress.Ipv4) LispAFIConvertor
- .toPrimitive(LispAFIConvertor.asIPAfiAddress("10.0.0.2"));
+ org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.lispsimpleaddress.primitiveaddress.Ipv4 address1 = (org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev150820.lispsimpleaddress.primitiveaddress.Ipv4) LispAddressUtil
+ .toPrimitive(LispAddressUtil.asIPAfiAddress("10.0.0.1"));
+ org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.lispsimpleaddress.primitiveaddress.Ipv4 address2 = (org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev150820.lispsimpleaddress.primitiveaddress.Ipv4) LispAddressUtil
+ .toPrimitive(LispAddressUtil.asIPAfiAddress("10.0.0.2"));
int mask1 = 32;
int mask2 = 32;
LcafSourceDestAddr sourceDestAddress = new LcafSourceDestAddrBuilder().setAfi(AddressFamilyNumberEnum.LCAF.getIanaCode())
.setLcafType((short) LispCanonicalAddressFormatEnum.SOURCE_DEST.getLispCode())
.setSrcAddress(new SrcAddressBuilder().setPrimitiveAddress(address1).build()).setSrcMaskLength((short) mask1)
.setDstAddress(new DstAddressBuilder().setPrimitiveAddress(address2).build()).setDstMaskLength((short) mask2).build();
- LispIpv4Address rloc = LispAFIConvertor.asIPAfiAddress("20.0.0.2");
+ LispIpv4Address rloc = LispAddressUtil.asIPAfiAddress("20.0.0.2");
// Insert mapping in the database
MapRegisterBuilder mapRegister = new MapRegisterBuilder();
EidToLocatorRecordBuilder etlr = new EidToLocatorRecordBuilder();
- etlr.setLispAddressContainer(LispAFIConvertor.toContainer(sourceDestAddress));
+ etlr.setLispAddressContainer(LispAddressUtil.toContainer(sourceDestAddress));
etlr.setMaskLength((short) mask1);
etlr.setRecordTtl(254);
etlr.setAuthoritative(false);
etlr.setAction(Action.NoAction);
LocatorRecordBuilder record = new LocatorRecordBuilder();
- record.setLispAddressContainer(LispAFIConvertor.toContainer(rloc));
+ record.setLispAddressContainer(LispAddressUtil.toContainer(rloc));
record.setRouted(true);
record.setRlocProbed(false);
record.setLocalLocator(false);
record.setMulticastWeight((short) 1);
etlr.setLocatorRecord(new ArrayList<LocatorRecord>());
etlr.getLocatorRecord().add(record.build());
- mapRegister.setEidToLocatorRecord(new ArrayList<EidToLocatorRecord>());
- mapRegister.getEidToLocatorRecord().add(etlr.build());
+ mapRegister.setMappingRecordItem(new ArrayList<MappingRecordItem>());
+ mapRegister.getMappingRecordItem().add(new MappingRecordItemBuilder().setMappingRecord(etlr.build()).build());
lms.handleMapRegister(mapRegister.build(), false);
// Get mapping using NB interface. No IID used
public void eidPrefixLookupIPv4() throws SocketTimeoutException {
cleanUP();
- runPrefixTest(LispAFIConvertor.asIPAfiAddress("1.2.3.4"), 16, LispAFIConvertor.asIPAfiAddress("1.2.3.2"),
- LispAFIConvertor.asIPAfiAddress("1.1.1.1"), (byte) 32);
+ runPrefixTest(LispAddressUtil.asIpv4PrefixEid("1.2.3.4/16"), LispAddressUtil.asIpv4PrefixEid("1.2.3.2/32"),
+ LispAddressUtil.asIpv4PrefixEid("1.1.1.1/32"));
}
public void eidPrefixLookupIPv6() throws SocketTimeoutException {
cleanUP();
- runPrefixTest(LispAFIConvertor.asIPv6AfiAddress("1:2:3:4:5:6:7:8"), 64, LispAFIConvertor.asIPv6AfiAddress("1:2:3:4:5:1:2:3"),
- LispAFIConvertor.asIPv6AfiAddress("1:2:3:1:2:3:1:2"), 128);
+ runPrefixTest(LispAddressUtil.asIpv6PrefixEid("1:2:3:4:5:6:7:8/64"), LispAddressUtil.asIpv6PrefixEid("1:2:3:4:5:1:2:3/128"),
+ LispAddressUtil.asIpv6PrefixEid("1:2:3:1:2:3:1:2/128"));
}
- private void runPrefixTest(LispAFIAddress registerEID, int registerdMask, LispAFIAddress matchedAddress, LispAFIAddress unMatchedAddress, int mask)
+ private void runPrefixTest(Eid registerEID, Eid matchedAddress, Eid unMatchedAddress)
throws SocketTimeoutException {
MapRegisterBuilder mapRegister = new MapRegisterBuilder();
mapRegister.setAuthenticationData(new byte[0]);
mapRegister.setNonce((long) 8);
mapRegister.setProxyMapReply(false);
- EidToLocatorRecordBuilder etlr = new EidToLocatorRecordBuilder();
+ MappingRecordBuilder etlr = new MappingRecordBuilder();
etlr.setRecordTtl(254);
etlr.setAction(Action.NoAction);
etlr.setAuthoritative(false);
etlr.setMapVersion((short) 0);
- etlr.setLispAddressContainer(LispAFIConvertor.toContainer(registerEID));
- etlr.setMaskLength((short) registerdMask);
+ etlr.setEid(registerEID);
etlr.setRecordTtl(254);
LocatorRecordBuilder record = new LocatorRecordBuilder();
- record.setLispAddressContainer(LispAFIConvertor.toContainer(LispAFIConvertor.asIPAfiAddress("4.3.2.1")));
+ record.setRloc(LispAddressUtil.asIpv4Rloc("4.3.2.1"));
record.setLocalLocator(false);
record.setRlocProbed(false);
record.setRouted(true);
record.setWeight((short) 0);
etlr.setLocatorRecord(new ArrayList<LocatorRecord>());
etlr.getLocatorRecord().add(record.build());
- mapRegister.setEidToLocatorRecord(new ArrayList<EidToLocatorRecord>());
- mapRegister.getEidToLocatorRecord().add(etlr.build());
+ mapRegister.setMappingRecordItem(new ArrayList<MappingRecordItem>());
+ mapRegister.getMappingRecordItem().add(new MappingRecordItemBuilder().setMappingRecord(etlr.build()).build());
sendMapRegister(mapRegister.build());
MapNotify mapNotify = receiveMapNotify();
assertEquals(8, mapNotify.getNonce().longValue());
sleepForSeconds(1);
MapRequestBuilder mapRequest = new MapRequestBuilder();
mapRequest.setNonce((long) 4);
- mapRequest.setSourceEid(new SourceEidBuilder().setLispAddressContainer(LispAFIConvertor.toContainer(LispAFIConvertor.asIPAfiAddress(ourAddress))).build());
- mapRequest.setEidRecord(new ArrayList<EidRecord>());
+ mapRequest.setSourceEid(new SourceEidBuilder().setEid(LispAddressUtil.asIpv4Eid(ourAddress)).build());
+ mapRequest.setEidItem(new ArrayList<EidItem>());
mapRequest.setAuthoritative(false);
mapRequest.setMapDataPresent(false);
mapRequest.setPitr(false);
mapRequest.setProbe(false);
mapRequest.setSmr(false);
mapRequest.setSmrInvoked(false);
- mapRequest.getEidRecord().add(
- new EidRecordBuilder().setMask((short) mask).setLispAddressContainer(LispAFIConvertor.toContainer(matchedAddress)).build());
+ mapRequest.getEidItem().add(new EidItemBuilder().setEid(matchedAddress).build());
mapRequest.setItrRloc(new ArrayList<ItrRloc>());
mapRequest.getItrRloc().add(
- new ItrRlocBuilder().setLispAddressContainer(LispAFIConvertor.toContainer(LispAFIConvertor.asIPAfiAddress(ourAddress))).build());
+ new ItrRlocBuilder().setRloc(LispAddressUtil.asIpv4Rloc(ourAddress)).build());
sendMapRequest(mapRequest.build());
MapReply mapReply = receiveMapReply();
assertEquals(4, mapReply.getNonce().longValue());
- assertEquals(record.getLispAddressContainer(), mapReply.getEidToLocatorRecord().get(0).getLocatorRecord().get(0).getLispAddressContainer());
- mapRequest.setEidRecord(new ArrayList<EidRecord>());
- mapRequest.getEidRecord().add(
- new EidRecordBuilder().setMask((short) mask).setLispAddressContainer(LispAFIConvertor.toContainer(unMatchedAddress)).build());
+ assertEquals(record.getRloc(), mapReply.getMappingRecordItem().get(0).getMappingRecord().getLocatorRecord().get(0).getRloc());
+ mapRequest.setEidItem(new ArrayList<EidItem>());
+ mapRequest.getEidItem().add(new EidItemBuilder().setEid(unMatchedAddress).build());
sendMapRequest(mapRequest.build());
mapReply = receiveMapReply();
- assertEquals(0, mapReply.getEidToLocatorRecord().get(0).getLocatorRecord().size());
+ assertEquals(0, mapReply.getMappingRecordItem().get(0).getMappingRecord().getLocatorRecord().size());
}
/*
// This registers an IP with a MapRegister, then adds a password via the
public void testPasswordExactMatch() throws Exception {
cleanUP();
String ipString = "10.0.0.1";
- LispIpv4Address address = LispAFIConvertor.asIPAfiAddress(ipString);
+ LispIpv4Address address = LispAddressUtil.asIPAfiAddress(ipString);
int mask = 32;
String pass = "pass";
mapRegister.setWantMapNotify(true);
mapRegister.setNonce((long) 8);
EidToLocatorRecordBuilder etlr = new EidToLocatorRecordBuilder();
- etlr.setLispAddressContainer(LispAFIConvertor.toContainer(address));
+ etlr.setLispAddressContainer(LispAddressUtil.toContainer(address));
etlr.setMaskLength((short) mask);
etlr.setRecordTtl(254);
LocatorRecordBuilder record = new LocatorRecordBuilder();
- record.setLispAddressContainer(LispAFIConvertor.toContainer(locatorEid));
+ record.setLispAddressContainer(LispAddressUtil.toContainer(locatorEid));
etlr.setLocatorRecord(new ArrayList<LocatorRecord>());
etlr.getLocatorRecord().add(record.build());
- mapRegister.setEidToLocatorRecord(new ArrayList<EidToLocatorRecord>());
- mapRegister.getEidToLocatorRecord().add(etlr.build());
+ mapRegister.setMappingRecordItem(new ArrayList<MappingRecordItem>());
+ mapRegister.getMappingRecordItem().add(new MappingRecordItemBuilder().setMappingRecord(etlr.build()).build());
mapRegister.setKeyId((short) 1); // LispKeyIDEnum.SHA1.getKeyID()
mapRegister.setAuthenticationData(zeros);
public void testPasswordMaskMatch() throws Exception {
cleanUP();
- LispIpv4Address addressInRange = LispAFIConvertor.asIPAfiAddress("10.20.30.40");
- LispIpv4Address addressOutOfRange = LispAFIConvertor.asIPAfiAddress("20.40.30.40");
- LispIpv4Address range = LispAFIConvertor.asIPAfiAddress("10.20.30.0");
+ LispIpv4Address addressInRange = LispAddressUtil.asIPAfiAddress("10.20.30.40");
+ LispIpv4Address addressOutOfRange = LispAddressUtil.asIPAfiAddress("20.40.30.40");
+ LispIpv4Address range = LispAddressUtil.asIPAfiAddress("10.20.30.0");
int mask = 32;
String pass = "pass";
mapRegister.setWantMapNotify(true);
mapRegister.setNonce((long) 8);
EidToLocatorRecordBuilder etlr = new EidToLocatorRecordBuilder();
- etlr.setLispAddressContainer(LispAFIConvertor.toContainer(addressInRange));
+ etlr.setLispAddressContainer(LispAddressUtil.toContainer(addressInRange));
etlr.setMaskLength((short) mask);
etlr.setRecordTtl(254);
LocatorRecordBuilder record = new LocatorRecordBuilder();
- record.setLispAddressContainer(LispAFIConvertor.toContainer(locatorEid));
- record.setLispAddressContainer(LispAFIConvertor.toContainer(locatorEid));
+ record.setLispAddressContainer(LispAddressUtil.toContainer(locatorEid));
+ record.setLispAddressContainer(LispAddressUtil.toContainer(locatorEid));
etlr.setLocatorRecord(new ArrayList<LocatorRecord>());
etlr.getLocatorRecord().add(record.build());
- mapRegister.setEidToLocatorRecord(new ArrayList<EidToLocatorRecord>());
- mapRegister.getEidToLocatorRecord().add(etlr.build());
+ mapRegister.setMappingRecordItem(new ArrayList<MappingRecordItem>());
+ mapRegister.getMappingRecordItem().add(new MappingRecordItemBuilder().setMappingRecord(etlr.build()).build());
mapRegister.setKeyId((short) 1); // LispKeyIDEnum.SHA1.getKeyID()
mapRegister
assertMapNotifyRecieved();
- etlr.setLispAddressContainer(LispAFIConvertor.toContainer(addressOutOfRange));
+ etlr.setLispAddressContainer(LispAddressUtil.toContainer(addressOutOfRange));
mapRegister
.setAuthenticationData(new byte[] { -54, 68, -58, -91, -23, 22, -88, -31, 113, 39, 115, 78, -68, -123, -71, -14, -99, 67, -23, -73 });
assertNoPacketReceived(3000);
}
*/
- private MapReply registerAddressAndQuery(LispAFIAddress eid) throws SocketTimeoutException {
- return registerAddressAndQuery(eid, -1);
- }
-
// takes an address, packs it in a MapRegister and sends it
- private void registerAddress(LispAddressContainer eid, int maskLength) throws SocketTimeoutException {
+ private void registerAddress(Eid eid) throws SocketTimeoutException {
MapRegisterBuilder mapRegisterBuilder = new MapRegisterBuilder();
mapRegisterBuilder.setWantMapNotify(true);
mapRegisterBuilder.setKeyId((short) 0);
mapRegisterBuilder.setAuthenticationData(new byte[0]);
mapRegisterBuilder.setNonce((long) 8);
mapRegisterBuilder.setProxyMapReply(false);
- EidToLocatorRecordBuilder etlrBuilder = new EidToLocatorRecordBuilder();
- etlrBuilder.setLispAddressContainer(eid);
- if (maskLength != -1) {
- etlrBuilder.setMaskLength((short) maskLength);
- } else {
- etlrBuilder.setMaskLength((short) 0);
- }
+ MappingRecordBuilder etlrBuilder = new MappingRecordBuilder();
+ etlrBuilder.setEid(eid);
etlrBuilder.setRecordTtl(254);
etlrBuilder.setAction(Action.NoAction);
etlrBuilder.setAuthoritative(false);
recordBuilder.setMulticastWeight((short) 0);
recordBuilder.setPriority((short) 0);
recordBuilder.setWeight((short) 0);
- recordBuilder.setLispAddressContainer(LispAFIConvertor.toContainer(locatorEid));
+ recordBuilder.setRloc(locatorEid);
etlrBuilder.setLocatorRecord(new ArrayList<LocatorRecord>());
etlrBuilder.getLocatorRecord().add(recordBuilder.build());
- mapRegisterBuilder.setEidToLocatorRecord(new ArrayList<EidToLocatorRecord>());
- mapRegisterBuilder.getEidToLocatorRecord().add(etlrBuilder.build());
+ mapRegisterBuilder.setMappingRecordItem(new ArrayList<MappingRecordItem>());
+ mapRegisterBuilder.getMappingRecordItem().add(new MappingRecordItemBuilder().setMappingRecord(etlrBuilder.build()).build());
sendMapRegister(mapRegisterBuilder.build());
MapNotify mapNotify = receiveMapNotify();
assertEquals(8, mapNotify.getNonce().longValue());
}
- private MapReply queryForAddress(LispAddressContainer eid, String srcEid) throws SocketTimeoutException {
+ private MapReply queryForAddress(Eid 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(eid).build());
+ mapRequestBuilder.setEidItem(new ArrayList<EidItem>());
+ mapRequestBuilder.getEidItem().add(new EidItemBuilder().setEid(eid).build());
mapRequestBuilder.setItrRloc(new ArrayList<ItrRloc>());
if (srcEid != null) {
- mapRequestBuilder.setSourceEid(new SourceEidBuilder().setLispAddressContainer(LispAFIConvertor.
- toContainer(LispAFIConvertor.asIPAfiAddress(srcEid))).build());
+ mapRequestBuilder.setSourceEid(new SourceEidBuilder().setEid(LispAddressUtil.asIpv4Eid(srcEid)).build());
} else {
- mapRequestBuilder.setSourceEid(new SourceEidBuilder().setLispAddressContainer(LispAFIConvertor.
- toContainer(LispAFIConvertor.asIPAfiAddress(ourAddress))).build());
+ mapRequestBuilder.setSourceEid(new SourceEidBuilder().setEid(LispAddressUtil.asIpv4Eid(ourAddress)).build());
}
mapRequestBuilder.getItrRloc().add(
- new ItrRlocBuilder().setLispAddressContainer(LispAFIConvertor.toContainer(LispAFIConvertor.asIPAfiAddress(ourAddress))).build());
+ new ItrRlocBuilder().setRloc(LispAddressUtil.asIpv4Rloc(ourAddress)).build());
mapRequestBuilder.setAuthoritative(false);
mapRequestBuilder.setMapDataPresent(false);
mapRequestBuilder.setPitr(false);
// takes an address, packs it in a MapRegister, sends it, returns the
// MapReply
- private MapReply registerAddressAndQuery(LispAFIAddress eid, int maskLength) throws SocketTimeoutException {
+ private MapReply registerAddressAndQuery(Eid eid) throws SocketTimeoutException {
MapRegisterBuilder mapRegisterBuilder = new MapRegisterBuilder();
mapRegisterBuilder.setWantMapNotify(true);
mapRegisterBuilder.setKeyId((short) 0);
mapRegisterBuilder.setAuthenticationData(new byte[0]);
mapRegisterBuilder.setNonce((long) 8);
mapRegisterBuilder.setProxyMapReply(false);
- EidToLocatorRecordBuilder etlrBuilder = new EidToLocatorRecordBuilder();
- etlrBuilder.setLispAddressContainer(LispAFIConvertor.toContainer(eid));
- if (maskLength != -1) {
- etlrBuilder.setMaskLength((short) maskLength);
- } else {
- etlrBuilder.setMaskLength((short) 0);
- }
+ MappingRecordBuilder etlrBuilder = new MappingRecordBuilder();
+ etlrBuilder.setEid(eid);
etlrBuilder.setRecordTtl(254);
etlrBuilder.setAction(Action.NoAction);
etlrBuilder.setAuthoritative(false);
recordBuilder.setMulticastWeight((short) 0);
recordBuilder.setPriority((short) 0);
recordBuilder.setWeight((short) 0);
- recordBuilder.setLispAddressContainer(LispAFIConvertor.toContainer(locatorEid));
+ recordBuilder.setRloc(locatorEid);
etlrBuilder.setLocatorRecord(new ArrayList<LocatorRecord>());
etlrBuilder.getLocatorRecord().add(recordBuilder.build());
- mapRegisterBuilder.setEidToLocatorRecord(new ArrayList<EidToLocatorRecord>());
- mapRegisterBuilder.getEidToLocatorRecord().add(etlrBuilder.build());
+ mapRegisterBuilder.setMappingRecordItem(new ArrayList<MappingRecordItem>());
+ mapRegisterBuilder.getMappingRecordItem().add(new MappingRecordItemBuilder().setMappingRecord(etlrBuilder.build()).build());
sendMapRegister(mapRegisterBuilder.build());
MapNotify mapNotify = receiveMapNotify();
assertEquals(8, mapNotify.getNonce().longValue());
sleepForSeconds(1);
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());
+ mapRequestBuilder.setEidItem(new ArrayList<EidItem>());
+ mapRequestBuilder.getEidItem().add(new EidItemBuilder().setEid(eid).build());
mapRequestBuilder.setItrRloc(new ArrayList<ItrRloc>());
- mapRequestBuilder.setSourceEid(new SourceEidBuilder().setLispAddressContainer(LispAFIConvertor.toContainer(LispAFIConvertor.asIPAfiAddress(ourAddress)))
- .build());
+ mapRequestBuilder.setSourceEid(new SourceEidBuilder().setEid(LispAddressUtil.asIpv4Eid(ourAddress)).build());
mapRequestBuilder.getItrRloc().add(
- new ItrRlocBuilder().setLispAddressContainer(LispAFIConvertor.toContainer(LispAFIConvertor.asIPAfiAddress(ourAddress))).build());
+ new ItrRlocBuilder().setRloc(LispAddressUtil.asIpv4Rloc(ourAddress)).build());
mapRequestBuilder.setAuthoritative(false);
mapRequestBuilder.setMapDataPresent(false);
mapRequestBuilder.setPitr(false);
}
// ------------------------------- LCAF Tests ---------------------------
-
+/*
@Test
public void registerAndQuery__SrcDestLCAF() throws SocketTimeoutException {
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.rev151105.lispsimpleaddress.primitiveaddress.Ipv4 addrToSend1 = LispAFIConvertor.asPrimitiveIPv4AfiPrefix(ipString, 32);
- org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.lispsimpleaddress.primitiveaddress.Mac addrToSend2 = LispAFIConvertor.asPrimitiveMacAfiAddress(macString);
+ org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.lispsimpleaddress.primitiveaddress.Ipv4 addrToSend1 = LispAddressUtil.asPrimitiveIPv4AfiPrefix(ipString, 32);
+ org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.lispsimpleaddress.primitiveaddress.Mac addrToSend2 = LispAddressUtil.asPrimitiveMacAfiAddress(macString);
LcafSourceDestAddrBuilder builder = new LcafSourceDestAddrBuilder();
builder.setAfi(AddressFamilyNumberEnum.LCAF.getIanaCode());
builder.setLcafType((short) LispCanonicalAddressFormatEnum.SOURCE_DEST.getLispCode());
MapReply reply = registerAddressAndQuery(builder.build());
- LispAddressContainer fromNetwork = reply.getEidToLocatorRecord().get(0).getLispAddressContainer();
+ Eid fromNetwork = reply.getMappingRecordItem().get(0).getMappingRecord().getEid();
assertTrue(fromNetwork.getAddress() instanceof LcafSourceDest);
LcafSourceDest sourceDestFromNetwork = (LcafSourceDest) fromNetwork.getAddress();
- LispAFIAddress receivedAddr1 = LispAFIConvertor.toAFIfromPrimitive(sourceDestFromNetwork.getLcafSourceDestAddr().getSrcAddress().getPrimitiveAddress());
- LispAFIAddress receivedAddr2 = LispAFIConvertor.toAFIfromPrimitive(sourceDestFromNetwork.getLcafSourceDestAddr().getDstAddress().getPrimitiveAddress());
+ LispAFIAddress receivedAddr1 = LispAddressUtil.toAFIfromPrimitive(sourceDestFromNetwork.getLcafSourceDestAddr().getSrcAddress().getPrimitiveAddress());
+ LispAFIAddress receivedAddr2 = LispAddressUtil.toAFIfromPrimitive(sourceDestFromNetwork.getLcafSourceDestAddr().getDstAddress().getPrimitiveAddress());
assertTrue(receivedAddr1 instanceof LispIpv4Address);
assertTrue(receivedAddr2 instanceof LispMacAddress);
assertEquals(ipString, receivedIP.getIpv4Address().getValue());
assertEquals(macString, receivedMAC.getMacAddress().getValue());
}
-
+*/
@Test
public void registerAndQuery__SrcDestLCAFOverlap() throws SocketTimeoutException {
cleanUP();
String ipString1 = "10.10.10.0";
String ipString2 = "20.20.20.0";
- org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.lispsimpleaddress.primitiveaddress.Ipv4 addrToSend1 = LispAFIConvertor.asPrimitiveIPv4AfiPrefix(ipString1, 24);
- org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.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.setSrcMaskLength((short) 24);
- builder.setDstMaskLength((short) 24);
- builder.setSrcAddress(new SrcAddressBuilder().setPrimitiveAddress(addrToSend1).build());
- builder.setDstAddress(new DstAddressBuilder().setPrimitiveAddress(addrToSend2).build());
+ String ipPrefix1 = ipString1 + "/24";
+ String ipPrefix2 = ipString2 + "/24";
- LispAddressContainer srcDst = LispAFIConvertor.toContainer(builder.build());
- registerAddress(LispAFIConvertor.asIPv4Prefix(ipString2, 24), 24);
- registerAddress(srcDst, -1);
+ Eid srcDst = LispAddressUtil.asSrcDstEid(ipString1, ipString2, 24, 24, 0);
+ registerAddress(LispAddressUtil.asIpv4PrefixEid(ipPrefix2));
+ registerAddress(srcDst);
// exact match
MapReply reply = queryForAddress(srcDst, null);
- LispAddressContainer fromNetwork = reply.getEidToLocatorRecord().get(0).getLispAddressContainer();
- assertTrue(fromNetwork.getAddress() instanceof LcafSourceDest);
- LcafSourceDest sourceDestFromNetwork = (LcafSourceDest) fromNetwork.getAddress();
-
- LispAFIAddress receivedAddr1 = LispAFIConvertor.toAFIfromPrimitive(sourceDestFromNetwork.getLcafSourceDestAddr().getSrcAddress().getPrimitiveAddress());
- LispAFIAddress receivedAddr2 = LispAFIConvertor.toAFIfromPrimitive(sourceDestFromNetwork.getLcafSourceDestAddr().getDstAddress().getPrimitiveAddress());
+ Eid fromNetwork = reply.getMappingRecordItem().get(0).getMappingRecord().getEid();
+ assertEquals(SourceDestKeyLcaf.class, fromNetwork.getAddressType());
+ SourceDestKey sourceDestFromNetwork = (SourceDestKey) fromNetwork.getAddress();
- assertTrue(receivedAddr1 instanceof LispIpv4Address);
- assertTrue(receivedAddr2 instanceof LispIpv4Address);
+ IpPrefix receivedAddr1 = sourceDestFromNetwork.getSourceDestKey().getSource();
+ IpPrefix receivedAddr2 = sourceDestFromNetwork.getSourceDestKey().getDest();
- LispIpv4Address receivedIP1 = (LispIpv4Address) receivedAddr1;
- LispIpv4Address receivedIP2 = (LispIpv4Address) receivedAddr2;
+ assertNotNull(receivedAddr1.getIpv4Prefix());
+ assertNotNull(receivedAddr2.getIpv4Prefix());
- assertEquals(ipString1, receivedIP1.getIpv4Address().getValue());
- assertEquals(ipString2, receivedIP2.getIpv4Address().getValue());
+ assertEquals(ipPrefix1, receivedAddr1.getIpv4Prefix().getValue());
+ assertEquals(ipPrefix2, receivedAddr2.getIpv4Prefix().getValue());
// srcEid/dstEid match
- 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.rev151105.lispaddress.lispaddresscontainer.address.Ipv4);
+ reply = queryForAddress(LispAddressUtil.asIpv4PrefixEid("20.20.20.1/32"), "10.10.10.1");
+ fromNetwork = reply.getMappingRecordItem().get(0).getMappingRecord().getEid();
+ assertEquals(Ipv4PrefixAfi.class, fromNetwork.getAddressType());
- Ipv4Address ipAddr2 = ((org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.lispaddress.lispaddresscontainer.address.Ipv4) fromNetwork.getAddress()).getIpv4Address();
- assertEquals(ipString2, ipAddr2.getIpv4Address().getValue());
+ Ipv4Prefix ipAddr2 = (Ipv4Prefix) fromNetwork.getAddress();
+ assertEquals(ipPrefix2, ipAddr2.getIpv4Prefix().getValue());
// dstEid match only
- 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.rev151105.lispaddress.lispaddresscontainer.address.Ipv4);
+ reply = queryForAddress(LispAddressUtil.asIpv4PrefixEid("20.20.20.1/32"), "1.2.3.4");
+ fromNetwork = reply.getMappingRecordItem().get(0).getMappingRecord().getEid();
+ assertEquals(Ipv4PrefixAfi.class, fromNetwork.getAddressType());
- ipAddr2 = ((org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.lispaddress.lispaddresscontainer.address.Ipv4) fromNetwork.getAddress()).getIpv4Address();
- assertEquals(ipString2, ipAddr2.getIpv4Address().getValue());
+ ipAddr2 = (Ipv4Prefix) fromNetwork.getAddress();
+ assertEquals(ipPrefix2, ipAddr2.getIpv4Prefix().getValue());
}
@Test
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.rev151105.lispsimpleaddress.primitiveaddress.Ipv4 addrToSend1 = LispAFIConvertor.asPrimitiveIPAfiAddress(ipString);
- org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.lispsimpleaddress.primitiveaddress.Mac addrToSend2 = LispAFIConvertor.asPrimitiveMacAfiAddress(macString);
- LcafKeyValueAddressAddrBuilder builder = new LcafKeyValueAddressAddrBuilder();
- builder.setAfi(AddressFamilyNumberEnum.LCAF.getIanaCode());
- builder.setLcafType((short) LispCanonicalAddressFormatEnum.KEY_VALUE.getLispCode());
- builder.setKey(new KeyBuilder().setPrimitiveAddress(addrToSend1).build());
- builder.setValue(new ValueBuilder().setPrimitiveAddress(addrToSend2).build());
+ SimpleAddress addrToSend1 = new SimpleAddress(new IpAddress(new Ipv4Address(ipString)));
+ SimpleAddress addrToSend2 = new SimpleAddress(new MacAddress(macString));
+ Eid kv = LispAddressUtil.asKeyValueAddressEid(addrToSend1, addrToSend2);
- MapReply reply = registerAddressAndQuery(builder.build());
+ MapReply reply = registerAddressAndQuery(kv);
- LispAddressContainer fromNetwork = reply.getEidToLocatorRecord().get(0).getLispAddressContainer();
- assertTrue(fromNetwork.getAddress() instanceof LcafKeyValue);
- LcafKeyValue keyValueFromNetwork = (LcafKeyValue) fromNetwork.getAddress();
+ Eid fromNetwork = reply.getMappingRecordItem().get(0).getMappingRecord().getEid();
+ assertEquals(KeyValueAddressLcaf.class, fromNetwork.getAddressType());
+ KeyValueAddress keyValueFromNetwork = (KeyValueAddress) fromNetwork.getAddress();
- LispAFIAddress receivedAddr1 = LispAFIConvertor.toAFIfromPrimitive(keyValueFromNetwork.getLcafKeyValueAddressAddr().getKey().getPrimitiveAddress());
- LispAFIAddress receivedAddr2 = LispAFIConvertor.toAFIfromPrimitive(keyValueFromNetwork.getLcafKeyValueAddressAddr().getValue().getPrimitiveAddress());
+ SimpleAddress receivedAddr1 = keyValueFromNetwork.getKeyValueAddress().getKey();
+ SimpleAddress receivedAddr2 = keyValueFromNetwork.getKeyValueAddress().getValue();
- assertTrue(receivedAddr1 instanceof LispIpv4Address);
- assertTrue(receivedAddr2 instanceof LispMacAddress);
+ assertNotNull(receivedAddr1.getIpAddress().getIpv4Address());
+ assertNotNull(receivedAddr2.getMacAddress());
- LispIpv4Address receivedIP = (LispIpv4Address) receivedAddr1;
- LispMacAddress receivedMAC = (LispMacAddress) receivedAddr2;
+ Ipv4Address receivedIP = receivedAddr1.getIpAddress().getIpv4Address();
+ MacAddress receivedMAC = receivedAddr2.getMacAddress();
- assertEquals(ipString, receivedIP.getIpv4Address().getValue());
- assertEquals(macString, receivedMAC.getMacAddress().getValue());
+ assertEquals(ipString, receivedIP.getValue());
+ assertEquals(macString, receivedMAC.getValue());
}
public void registerAndQuery__ListLCAF() throws SocketTimeoutException {
cleanUP();
String macString = "01:02:03:04:05:06";
String ipString = "10.20.255.30";
- LcafListAddrBuilder listbuilder = new LcafListAddrBuilder();
- listbuilder.setAfi(AddressFamilyNumberEnum.LCAF.getIanaCode()).setLcafType((short) LispCanonicalAddressFormatEnum.LIST.getLispCode());
- listbuilder.setAddresses(new ArrayList<Addresses>());
- listbuilder.getAddresses().add(new AddressesBuilder().setPrimitiveAddress(LispAFIConvertor.toPrimitive(LispAFIConvertor.asIPAfiAddress(ipString))).build());
- listbuilder.getAddresses().add(new AddressesBuilder().setPrimitiveAddress(LispAFIConvertor.toPrimitive(LispAFIConvertor.asMacAfiAddress(macString))).build());
+ List<SimpleAddress> addresses = new ArrayList<SimpleAddress>();
+ addresses.add(new SimpleAddress(new IpAddress(new Ipv4Address(ipString))));
+ addresses.add(new SimpleAddress(new MacAddress(macString)));
+ AfiListBuilder listbuilder = new AfiListBuilder();
+ listbuilder.setAddressList(addresses);
- MapReply reply = registerAddressAndQuery(listbuilder.build());
+ EidBuilder eb = new EidBuilder();
+ eb.setAddressType(AfiListLcaf.class);
+ eb.setVirtualNetworkId(null);
+ eb.setAddress(new org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.lisp.address.types.rev151105.lisp.address.address.AfiListBuilder()
+ .setAfiList(listbuilder.build()).build());
- LispAFIAddress receivedAddress = LispAFIConvertor.toAFI(reply.getEidToLocatorRecord().get(0).getLispAddressContainer());
+ MapReply reply = registerAddressAndQuery(eb.build());
- assertTrue(receivedAddress instanceof LcafListAddress);
+ Eid receivedAddress = reply.getMappingRecordItem().get(0).getMappingRecord().getEid();
- LcafListAddress listAddrFromNetwork = (LcafListAddress) receivedAddress;
- LispAFIAddress receivedAddr1 = LispAFIConvertor.toAFIfromPrimitive(listAddrFromNetwork.getAddresses().get(0).getPrimitiveAddress());
- LispAFIAddress receivedAddr2 = LispAFIConvertor.toAFIfromPrimitive(listAddrFromNetwork.getAddresses().get(1).getPrimitiveAddress());
+ assertEquals(AfiListLcaf.class, receivedAddress.getAddressType());
- assertTrue(receivedAddr1 instanceof LispIpv4Address);
- assertTrue(receivedAddr2 instanceof LispMacAddress);
+ AfiList listAddrFromNetwork = (AfiList) receivedAddress.getAddress();
+ SimpleAddress receivedAddr1 = listAddrFromNetwork.getAfiList().getAddressList().get(0);
+ SimpleAddress receivedAddr2 = listAddrFromNetwork.getAfiList().getAddressList().get(1);
- assertEquals(macString, ((LispMacAddress) receivedAddr2).getMacAddress().getValue());
- assertEquals(ipString, ((LispIpv4Address) receivedAddr1).getIpv4Address().getValue());
+ assertNotNull(receivedAddr1.getIpAddress().getIpv4Address());
+ assertNotNull(receivedAddr2.getMacAddress());
+
+ assertEquals(macString, receivedAddr2.getMacAddress().getValue());
+ assertEquals(ipString, receivedAddr1.getIpAddress().getIpv4Address().getValue());
}
public void registerAndQuery__SegmentLCAF() throws SocketTimeoutException {
cleanUP();
String ipString = "10.20.255.30";
int instanceId = 6;
- LcafSegmentAddrBuilder builder = new LcafSegmentAddrBuilder();
- builder.setInstanceId((long) instanceId);
- builder.setIidMaskLength((short) 32);
- builder.setAfi(AddressFamilyNumberEnum.LCAF.getIanaCode()).setLcafType((short) LispCanonicalAddressFormatEnum.SEGMENT.getLispCode());
- builder.setAddress(new AddressBuilder().setPrimitiveAddress(LispAFIConvertor.toPrimitive(LispAFIConvertor.asIPAfiAddress(ipString))).build());
- MapReply reply = registerAddressAndQuery(builder.build());
+ EidBuilder eb = new EidBuilder();
+ eb.setAddressType(Ipv4PrefixAfi.class);
+ eb.setVirtualNetworkId(new InstanceIdType((long) instanceId));
+ eb.setAddress(new Ipv4PrefixBuilder().setIpv4Prefix(new org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev100924.Ipv4Prefix(
+ ipString)).build());
+
+ MapReply reply = registerAddressAndQuery(eb.build());
- LispAFIAddress receivedAddress = LispAFIConvertor.toAFI(reply.getEidToLocatorRecord().get(0).getLispAddressContainer());
- assertTrue(receivedAddress instanceof LcafSegmentAddress);
+ Eid receivedAddress = reply.getMappingRecordItem().get(0).getMappingRecord().getEid();
+ assertEquals(Ipv4PrefixAfi.class, receivedAddress.getAddressType());
- LcafSegmentAddress segmentfromNetwork = (LcafSegmentAddress) receivedAddress;
- LispAFIAddress addrFromSegment = LispAFIConvertor.toAFIfromPrimitive(segmentfromNetwork.getAddress().getPrimitiveAddress());
- assertTrue(addrFromSegment instanceof LispIpv4Address);
- assertEquals(ipString, ((LispIpv4Address) addrFromSegment).getIpv4Address().getValue());
+ assertEquals(ipString, ((Ipv4Prefix) receivedAddress.getAddress()).getIpv4Prefix().getValue());
- assertEquals(instanceId, segmentfromNetwork.getInstanceId().intValue());
+ assertEquals(instanceId, receivedAddress.getVirtualNetworkId().getValue().intValue());
}
public void registerAndQuery__TrafficEngineering() throws SocketTimeoutException {
String macString = "01:02:03:04:05:06";
String ipString = "10.20.255.30";
HopBuilder hopBuilder = new HopBuilder();
- hopBuilder.setPrimitiveAddress(LispAFIConvertor.toPrimitive(LispAFIConvertor.asIPAfiAddress(ipString)));
+ hopBuilder.setAddress(new SimpleAddress(new IpAddress(new Ipv4Address(ipString))));
+ hopBuilder.setLrsBits(new LrsBits(true, false, true));
Hop hop1 = hopBuilder.build();
- hopBuilder.setPrimitiveAddress(LispAFIConvertor.toPrimitive(LispAFIConvertor.asMacAfiAddress(macString)));
+ hopBuilder.setAddress(new SimpleAddress(new MacAddress(macString)));
+ hopBuilder.setLrsBits(new LrsBits(false, true, false));
Hop hop2 = hopBuilder.build();
- HopsBuilder hb = new HopsBuilder();
- hb.setHop(hop1);
- hb.setLookup(true);
- hb.setRLOCProbe(false);
- hb.setStrict(true);
- HopsBuilder hb2 = new HopsBuilder();
- hb2.setHop(hop2);
- hb2.setLookup(false);
- hb2.setRLOCProbe(true);
- hb2.setStrict(false);
- Hops hops1 = hb.build();
- Hops hops2 = hb2.build();
- LcafTrafficEngineeringAddrBuilder trafficBuilder = new LcafTrafficEngineeringAddrBuilder();
- trafficBuilder.setAfi(AddressFamilyNumberEnum.LCAF.getIanaCode()).setLcafType(
- (short) LispCanonicalAddressFormatEnum.TRAFFIC_ENGINEERING.getLispCode());
- trafficBuilder.setHops(new ArrayList<Hops>());
- trafficBuilder.getHops().add(hb.build());
- trafficBuilder.getHops().add(hb2.build());
-
- MapReply reply = registerAddressAndQuery(trafficBuilder.build());
-
- assertTrue(LispAFIConvertor.toAFI(reply.getEidToLocatorRecord().get(0).getLispAddressContainer()) instanceof LcafTrafficEngineeringAddress);
-
- LcafTrafficEngineeringAddress receivedAddress = (LcafTrafficEngineeringAddress) LispAFIConvertor.toAFI(reply.getEidToLocatorRecord().get(0)
- .getLispAddressContainer());
-
- ReencapHop receivedHop1 = receivedAddress.getHops().get(0);
- ReencapHop receivedHop2 = receivedAddress.getHops().get(1);
-
- assertEquals(true, hops1.isLookup());
- assertEquals(false, hops1.isRLOCProbe());
- assertEquals(true, hops1.isStrict());
-
- assertEquals(false, hops2.isLookup());
- assertEquals(true, hops2.isRLOCProbe());
- assertEquals(false, hops2.isStrict());
-
- assertTrue(receivedHop1.getHop().getPrimitiveAddress() instanceof org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.lispsimpleaddress.primitiveaddress.Ipv4);
- assertTrue(receivedHop2.getHop().getPrimitiveAddress() instanceof org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.lispsimpleaddress.primitiveaddress.Mac);
-
- assertEquals(ipString, ((org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.lispsimpleaddress.primitiveaddress.Ipv4) receivedHop1.getHop().getPrimitiveAddress()).getIpv4Address().getIpv4Address().getValue());
- assertEquals(macString, ((org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.lispsimpleaddress.primitiveaddress.Mac) receivedHop2.getHop().getPrimitiveAddress()).getMacAddress().getMacAddress().getValue());
+ ExplicitLocatorPathBuilder elpBuilder = new ExplicitLocatorPathBuilder();
+ elpBuilder.setHop(new ArrayList<Hop>());
+ elpBuilder.getHop().add(hop1);
+ elpBuilder.getHop().add(hop2);
+
+ EidBuilder eb = new EidBuilder();
+ eb.setAddressType(ExplicitLocatorPathLcaf.class);
+ eb.setVirtualNetworkId(null);
+ eb.setAddress(new org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.lisp.address.types.rev151105.lisp.address.address.ExplicitLocatorPathBuilder()
+ .setExplicitLocatorPath(elpBuilder.build()).build());
+
+ MapReply reply = registerAddressAndQuery(eb.build());
+
+ assertEquals(ExplicitLocatorPathLcaf.class, reply.getMappingRecordItem().get(0).getMappingRecord().getEid().getAddressType());
+
+ ExplicitLocatorPath receivedAddress = (ExplicitLocatorPath) reply.getMappingRecordItem().get(0).getMappingRecord().getEid().getAddress();
+
+ Hop receivedHop1 = receivedAddress.getExplicitLocatorPath().getHop().get(0);
+ Hop receivedHop2 = receivedAddress.getExplicitLocatorPath().getHop().get(1);
+
+ assertEquals(true, receivedHop1.getLrsBits().isLookup());
+ assertEquals(false, receivedHop1.getLrsBits().isRlocProbe());
+ assertEquals(true, receivedHop1.getLrsBits().isStrict());
+
+ assertEquals(false, receivedHop2.getLrsBits().isLookup());
+ assertEquals(true, receivedHop2.getLrsBits().isRlocProbe());
+ assertEquals(false, receivedHop2.getLrsBits().isStrict());
+
+ assertNotNull(receivedHop1.getAddress().getIpAddress().getIpv4Address());
+ assertNotNull(receivedHop2.getAddress().getMacAddress());
+
+ assertEquals(ipString, receivedHop1.getAddress().getIpAddress().getIpv4Address().getValue());
+ assertEquals(macString, receivedHop2.getAddress().getMacAddress().getValue());
}
public void registerAndQuery__ApplicationData() throws SocketTimeoutException {
int remotePortLow = 4;
int remotePortHigh = 5;
- LcafApplicationDataAddrBuilder builder = new LcafApplicationDataAddrBuilder();
- builder.setAfi(AddressFamilyNumberEnum.LCAF.getIanaCode()).setLcafType((short) LispCanonicalAddressFormatEnum.APPLICATION_DATA.getLispCode());
+ ApplicationDataBuilder builder = new ApplicationDataBuilder();
builder.setIpTos(ipTOs);
builder.setProtocol(protocol);
builder.setLocalPortLow(new PortNumber(localPortLow));
builder.setLocalPortHigh(new PortNumber(localPortHigh));
builder.setRemotePortLow(new PortNumber(remotePortLow));
builder.setRemotePortHigh(new PortNumber(remotePortHigh));
- builder.setAddress(new org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.lcafapplicationdataaddress.AddressBuilder()
- .setPrimitiveAddress(LispAFIConvertor.toPrimitive(LispAFIConvertor.asIPAfiAddress(ipString))).build());
+ builder.setAddress(new SimpleAddress(new IpAddress(new Ipv4Address(ipString))));
- LcafApplicationDataAddress addressToSend = builder.build();
+ EidBuilder eb = new EidBuilder();
+ eb.setAddressType(ApplicationDataLcaf.class);
+ eb.setVirtualNetworkId(null);
+ eb.setAddress(new org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.lisp.address.types.rev151105.lisp.address.address.ApplicationDataBuilder()
+ .setApplicationData(builder.build()).build());
+ Eid addressToSend = eb.build();
MapReply reply = registerAddressAndQuery(addressToSend);
- LispAFIAddress receivedAddress = LispAFIConvertor.toAFI(reply.getEidToLocatorRecord().get(0).getLispAddressContainer());
+ Eid receivedAddress = reply.getMappingRecordItem().get(0).getMappingRecord().getEid();
- assertTrue(receivedAddress instanceof LcafApplicationDataAddress);
+ assertEquals(ApplicationDataLcaf.class, receivedAddress.getAddressType());
- LcafApplicationDataAddress receivedApplicationDataAddress = (LcafApplicationDataAddress) receivedAddress;
- assertEquals(protocol, receivedApplicationDataAddress.getProtocol().intValue());
- assertEquals(ipTOs, receivedApplicationDataAddress.getIpTos().intValue());
- assertEquals(localPortLow, receivedApplicationDataAddress.getLocalPortLow().getValue().intValue());
- assertEquals(localPortHigh, receivedApplicationDataAddress.getLocalPortHigh().getValue().intValue());
- assertEquals(remotePortLow, receivedApplicationDataAddress.getRemotePortLow().getValue().intValue());
- assertEquals(remotePortHigh, receivedApplicationDataAddress.getRemotePortHigh().getValue().intValue());
+ ApplicationData receivedApplicationDataAddress = (ApplicationData) receivedAddress.getAddress();
+ assertEquals(protocol, receivedApplicationDataAddress.getApplicationData().getProtocol().intValue());
+ assertEquals(ipTOs, receivedApplicationDataAddress.getApplicationData().getIpTos().intValue());
+ assertEquals(localPortLow, receivedApplicationDataAddress.getApplicationData().getLocalPortLow().getValue().intValue());
+ assertEquals(localPortHigh, receivedApplicationDataAddress.getApplicationData().getLocalPortHigh().getValue().intValue());
+ assertEquals(remotePortLow, receivedApplicationDataAddress.getApplicationData().getRemotePortLow().getValue().intValue());
+ assertEquals(remotePortHigh, receivedApplicationDataAddress.getApplicationData().getRemotePortHigh().getValue().intValue());
- LispIpv4Address ipAddressReceived = (LispIpv4Address) LispAFIConvertor.toAFIfromPrimitive(receivedApplicationDataAddress.getAddress().getPrimitiveAddress());
- assertEquals(ipString, ipAddressReceived.getIpv4Address().getValue());
+ SimpleAddress ipAddressReceived = receivedApplicationDataAddress.getApplicationData().getAddress();
+ assertEquals(ipString, ipAddressReceived.getIpAddress().getIpv4Address().getValue());
}
// ------------------- TimeOut Tests -----------
public void mapRequestMapRegisterAndMapRequestTestTimeout() throws SocketTimeoutException {
cleanUP();
- LispIpv4Address eid = LispAFIConvertor.asIPAfiAddress("1.2.3.4");
+ Eid eid = LispAddressUtil.asIpv4PrefixEid("1.2.3.4/32");
MapRequestBuilder mapRequestBuilder = new MapRequestBuilder();
mapRequestBuilder.setNonce((long) 4);
- mapRequestBuilder.setSourceEid(new SourceEidBuilder().setLispAddressContainer(
- LispAFIConvertor.toContainer(new NoAddressBuilder().setAfi((short) 0).build())).build());
- mapRequestBuilder.setEidRecord(new ArrayList<EidRecord>());
- mapRequestBuilder.getEidRecord().add(
- new EidRecordBuilder().setMask((short) 32).setLispAddressContainer(LispAFIConvertor.toContainer(eid)).build());
+ mapRequestBuilder.setSourceEid(new SourceEidBuilder().setEid(LispAddressUtil.getNoAddressEid()).build());
+ mapRequestBuilder.setEidItem(new ArrayList<EidItem>());
+ mapRequestBuilder.getEidItem().add(new EidItemBuilder().setEid(eid).build());
mapRequestBuilder.setItrRloc(new ArrayList<ItrRloc>());
mapRequestBuilder.getItrRloc().add(
- new ItrRlocBuilder().setLispAddressContainer(LispAFIConvertor.toContainer(LispAFIConvertor.asIPAfiAddress(ourAddress))).build());
+ new ItrRlocBuilder().setRloc(LispAddressUtil.asIpv4Rloc(ourAddress)).build());
sendMapRequest(mapRequestBuilder.build());
MapReply mapReply = receiveMapReply();
assertEquals(4, mapReply.getNonce().longValue());
- assertEquals(0, mapReply.getEidToLocatorRecord().get(0).getLocatorRecord().size());
+ assertEquals(0, mapReply.getMappingRecordItem().get(0).getMappingRecord().getLocatorRecord().size());
MapRegisterBuilder mapRegisterbuilder = new MapRegisterBuilder();
mapRegisterbuilder.setWantMapNotify(true);
mapRegisterbuilder.setNonce((long) 8);
- EidToLocatorRecordBuilder etlrBuilder = new EidToLocatorRecordBuilder();
- etlrBuilder.setLispAddressContainer(LispAFIConvertor.toContainer(eid));
+ MappingRecordBuilder etlrBuilder = new MappingRecordBuilder();
+ etlrBuilder.setEid(eid);
etlrBuilder.setMaskLength((short) 32);
etlrBuilder.setRecordTtl(254);
LocatorRecordBuilder recordBuilder = new LocatorRecordBuilder();
- recordBuilder.setLispAddressContainer(LispAFIConvertor.toContainer(LispAFIConvertor.asIPAfiAddress("4.3.2.1")));
+ recordBuilder.setRloc(LispAddressUtil.asIpv4Rloc("4.3.2.1"));
etlrBuilder.setLocatorRecord(new ArrayList<LocatorRecord>());
etlrBuilder.getLocatorRecord().add(recordBuilder.build());
- mapRegisterbuilder.setEidToLocatorRecord(new ArrayList<EidToLocatorRecord>());
- mapRegisterbuilder.getEidToLocatorRecord().add(etlrBuilder.build());
+ mapRegisterbuilder.setMappingRecordItem(new ArrayList<MappingRecordItem>());
+ mapRegisterbuilder.getMappingRecordItem().add(
+ new MappingRecordItemBuilder().setMappingRecord(etlrBuilder.build()).build());
sendMapRegister(mapRegisterbuilder.build());
MapNotify mapNotify = receiveMapNotify();
sendMapRequest(mapRequestBuilder.build());
mapReply = receiveMapReply();
assertEquals(4, mapReply.getNonce().longValue());
- assertEquals(recordBuilder.getLispAddressContainer(), mapReply.getEidToLocatorRecord().get(0).getLocatorRecord().get(0)
- .getLispAddressContainer());
+ assertEquals(recordBuilder.getRloc(), mapReply.getMappingRecordItem().get(0).getMappingRecord()
+ .getLocatorRecord().get(0).getRloc());
causeEntryToBeCleaned();
sendMapRequest(mapRequestBuilder.build());
mapReply = receiveMapReply();
- assertEquals(0, mapReply.getEidToLocatorRecord().get(0).getLocatorRecord().size());
+ assertEquals(0, mapReply.getMappingRecordItem().get(0).getMappingRecord().getLocatorRecord().size());
}
public void mapRequestMapRegisterAndMapRequestTestNativelyForwardTimeoutResponse() throws Exception {
cleanUP();
- LispIpv4Address eid = LispAFIConvertor.asIPAfiAddress("1.2.3.4");
+ Eid eid = LispAddressUtil.asIpv6PrefixEid("1.2.3.4/32");
MapRequest mapRequest = createMapRequest(eid);
testTTLBeforeRegister(mapRequest);
MapReply mapReply;
sendMapRequest(mapRequest);
mapReply = receiveMapReply();
- assertEquals(LispAFIConvertor.toContainer(LispAFIConvertor.asIPAfiAddress("4.3.2.1")), mapReply.getEidToLocatorRecord().get(0).getLocatorRecord().get(0)
- .getLispAddressContainer());
+ assertEquals(LispAddressUtil.asIpv4Rloc("4.3.2.1"), mapReply.getMappingRecordItem().get(0).getMappingRecord()
+ .getLocatorRecord().get(0).getRloc());
assertCorrectMapReplyTTLAndAction(mapReply, 254, Action.NoAction);
}
- private void registerForTTL(LispIpv4Address eid) throws SocketTimeoutException {
+ private void registerForTTL(Eid eid) throws SocketTimeoutException {
MapRegister mapRegister = createMapRegister(eid);
sendMapRegister(mapRegister);
assertMapNotifyRecieved();
}
*/
private void assertCorrectMapReplyTTLAndAction(MapReply mapReply, int expectedTTL, Action expectedAction) {
- assertEquals(expectedTTL, mapReply.getEidToLocatorRecord().get(0).getRecordTtl().intValue());
- assertEquals(expectedAction, mapReply.getEidToLocatorRecord().get(0).getAction());
+ assertEquals(expectedTTL, mapReply.getMappingRecordItem().get(0).getMappingRecord().getRecordTtl().intValue());
+ assertEquals(expectedAction, mapReply.getMappingRecordItem().get(0).getMappingRecord().getAction());
}
- private MapRegister createMapRegister(LispAFIAddress eid, LispAFIAddress rloc) {
+ private MapRegister createMapRegister(Eid eid, Rloc rloc) {
MapRegisterBuilder mapRegisterbuilder = new MapRegisterBuilder();
mapRegisterbuilder.setWantMapNotify(true);
mapRegisterbuilder.setNonce((long) 8);
mapRegisterbuilder.setKeyId((short) 0);
- EidToLocatorRecordBuilder etlrBuilder = new EidToLocatorRecordBuilder();
- etlrBuilder.setLispAddressContainer(LispAFIConvertor.toContainer(eid));
+ MappingRecordBuilder etlrBuilder = new MappingRecordBuilder();
+ etlrBuilder.setEid(eid);
etlrBuilder.setMaskLength((short) 24);
etlrBuilder.setRecordTtl(254);
etlrBuilder.setAuthoritative(false);
etlrBuilder.setAction(Action.NoAction);
LocatorRecordBuilder recordBuilder = new LocatorRecordBuilder();
- recordBuilder.setLispAddressContainer(LispAFIConvertor.toContainer(rloc));
+ recordBuilder.setRloc(rloc);
etlrBuilder.setLocatorRecord(new ArrayList<LocatorRecord>());
etlrBuilder.getLocatorRecord().add(recordBuilder.build());
- mapRegisterbuilder.setEidToLocatorRecord(new ArrayList<EidToLocatorRecord>());
- mapRegisterbuilder.getEidToLocatorRecord().add(etlrBuilder.build());
+ mapRegisterbuilder.setMappingRecordItem(new ArrayList<MappingRecordItem>());
+ mapRegisterbuilder.getMappingRecordItem().add(
+ new MappingRecordItemBuilder().setMappingRecord(etlrBuilder.build()).build());
MapRegister mapRegister = mapRegisterbuilder.build();
return mapRegister;
}
- private MapRegister createMapRegister(LispIpv4Address eid) {
- return createMapRegister(eid, LispAFIConvertor.asIPAfiAddress("4.3.2.1"));
+ private MapRegister createMapRegister(Eid eid) {
+ return createMapRegister(eid, LispAddressUtil.asIpv4Rloc("4.3.2.1"));
}
- private MapRequest createMapRequest(LispAFIAddress eid) {
+ private MapRequest createMapRequest(Eid eid) {
MapRequestBuilder mapRequestBuilder = new MapRequestBuilder();
mapRequestBuilder.setNonce((long) 4);
mapRequestBuilder.setPitr(false);
- mapRequestBuilder.setSourceEid(new SourceEidBuilder().setLispAddressContainer(
- LispAFIConvertor.toContainer(new NoAddressBuilder().setAfi((short) 0).build())).build());
- mapRequestBuilder.setEidRecord(new ArrayList<EidRecord>());
- mapRequestBuilder.getEidRecord().add(
- new EidRecordBuilder().setMask((short) 32).setLispAddressContainer(LispAFIConvertor.toContainer(eid)).build());
+ mapRequestBuilder.setSourceEid(new SourceEidBuilder().setEid(LispAddressUtil.getNoAddressEid()).build());
+ mapRequestBuilder.setEidItem(new ArrayList<EidItem>());
+ mapRequestBuilder.getEidItem().add(new EidItemBuilder().setEid(eid).build());
mapRequestBuilder.setItrRloc(new ArrayList<ItrRloc>());
mapRequestBuilder.getItrRloc().add(
- new ItrRlocBuilder().setLispAddressContainer(LispAFIConvertor.toContainer(LispAFIConvertor.asIPAfiAddress(ourAddress))).build());
+ new ItrRlocBuilder().setRloc(LispAddressUtil.asIpv4Rloc(ourAddress)).build());
MapRequest mr = mapRequestBuilder.build();
return mr;
}
cleanUP();
String rloc = "127.0.0.3";
int port = LispMessage.PORT_NUM;
- LispAFIAddress ipRloc = LispAFIConvertor.asIPAfiAddress(rloc);
+ Rloc ipRloc = LispAddressUtil.asIpv4Rloc(rloc);
sendProxyMapRequest(rloc, port, ipRloc);
}
cleanUP();
String rloc = "127.0.0.3";
int port = 4350;
- LcafApplicationDataAddr adLcaf = new LcafApplicationDataAddrBuilder()
- .setAfi(AddressFamilyNumberEnum.LCAF.getIanaCode())
- .setLcafType((short) LispCanonicalAddressFormatEnum.APPLICATION_DATA.getLispCode())
- .setAddress(
- new org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.lcafapplicationdataaddress.AddressBuilder().setPrimitiveAddress(
- LispAFIConvertor.asPrimitiveIPAfiAddress(rloc)).build()).setLocalPortLow(new PortNumber(port)).build();
- LOG.info("testNonProxyOtherPort:" + adLcaf.toString());
+
+ RlocBuilder rb = new RlocBuilder();
+ rb.setAddressType(ApplicationDataLcaf.class);
+ rb.setVirtualNetworkId(null);
+ rb.setAddress(new org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.lisp.address.types.rev151105.lisp.address.address.ApplicationDataBuilder()
+ .setApplicationData(new ApplicationDataBuilder().setAddress(new SimpleAddress(new IpAddress(
+ new Ipv4Address(rloc)))).setLocalPortLow(new PortNumber(port)).build()).build());
+ Rloc adLcaf = rb.build();
+
+ LOG.info("testNonProxyOtherPort:" + LispAddressStringifier.getString(adLcaf));
sendProxyMapRequest(rloc, port, adLcaf);
}
- private class XtrRequestMappingListener implements LispProtoListener {
+ private class XtrRequestMappingListener implements OdlLispProtoListener {
@Override
public void onGotMapReply(GotMapReply notification) {
cleanUP();
configLispPlugin.shouldListenOnXtrPort(true);
notificationCalled = false;
- final String eid = "10.10.10.10";
+ final String eid = "10.10.10.10/32";
String rloc = "127.0.0.3";
int port = LispMessage.XTR_PORT_NUM;
- LcafApplicationDataAddr adLcaf = new LcafApplicationDataAddrBuilder()
- .setAfi(AddressFamilyNumberEnum.LCAF.getIanaCode())
- .setLcafType((short) LispCanonicalAddressFormatEnum.APPLICATION_DATA.getLispCode())
- .setAddress(
- new org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.lcafapplicationdataaddress.AddressBuilder().setPrimitiveAddress(
- LispAFIConvertor.asPrimitiveIPAfiAddress(rloc)).build()).setLocalPortLow(new PortNumber(port)).build();
+
+ RlocBuilder rb = new RlocBuilder();
+ rb.setAddressType(ApplicationDataLcaf.class);
+ rb.setVirtualNetworkId(null);
+ rb.setAddress(new org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.lisp.address.types.rev151105.lisp.address.address.ApplicationDataBuilder()
+ .setApplicationData(new ApplicationDataBuilder().setAddress(new SimpleAddress(new IpAddress(
+ new Ipv4Address(rloc)))).setLocalPortLow(new PortNumber(port)).build()).build());
+ Rloc adLcaf = rb.build();
+
final MapRequest mapRequest = createNonProxyMapRequest(eid, adLcaf);
((LispMappingService) lms).getNotificationService().registerNotificationListener(new XtrRequestMappingListener() {
@Override
public void onXtrRequestMapping(XtrRequestMapping notification) {
- assertEquals(((org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.lispaddress.lispaddresscontainer.address.Ipv4) mapRequest.getEidRecord().get(0).getLispAddressContainer().getAddress()).getIpv4Address().getIpv4Address().getValue(),
- eid);
+ assertEquals(((Ipv4Prefix) mapRequest.getEidItem().get(0).getEid().getAddress())
+ .getIpv4Prefix().getValue(), eid);
notificationCalled = true;
LOG.warn("notification arrived");
}
}
- private void sendProxyMapRequest(String rloc, int port, LispAFIAddress adLcaf) throws SocketTimeoutException, SocketException {
- String eid = "10.1.0.1";
+ private void sendProxyMapRequest(String rloc, int port, Rloc adLcaf) throws SocketTimeoutException, SocketException {
+ String eid = "10.1.0.1/32";
MapRequest mapRequest = createNonProxyMapRequest(eid, adLcaf);
sendMapRequest(mapRequest);
DatagramSocket nonProxySocket = new DatagramSocket(new InetSocketAddress(rloc, port));
assertEquals(mapRequest.getNonce(), recievedMapRequest.getNonce());
assertEquals(mapRequest.getSourceEid(), recievedMapRequest.getSourceEid());
assertEquals(mapRequest.getItrRloc(), recievedMapRequest.getItrRloc());
- assertEquals(mapRequest.getEidRecord(), recievedMapRequest.getEidRecord());
+ assertEquals(mapRequest.getEidItem(), recievedMapRequest.getEidItem());
nonProxySocket.close();
}
- private MapRequest createNonProxyMapRequest(String eid, LispAFIAddress adLcaf) throws SocketTimeoutException {
- MapRegister mr = createMapRegister(LispAFIConvertor.asIPAfiAddress(eid));
- LocatorRecord record = new LocatorRecordBuilder(mr.getEidToLocatorRecord().get(0).getLocatorRecord().get(0)).setLispAddressContainer(
- LispAFIConvertor.toContainer(adLcaf)).build();
- mr.getEidToLocatorRecord().get(0).getLocatorRecord().set(0, record);
+ private MapRequest createNonProxyMapRequest(String eid, Rloc adLcaf) throws SocketTimeoutException {
+ MapRegister mr = createMapRegister(LispAddressUtil.asIpv4PrefixEid(eid));
+ LocatorRecord record = new LocatorRecordBuilder(mr.getMappingRecordItem().get(0).getMappingRecord()
+ .getLocatorRecord().get(0)).setRloc(adLcaf).build();
+ mr.getMappingRecordItem().get(0).getMappingRecord().getLocatorRecord().set(0, record);
sendMapRegister(mr);
assertMapNotifyRecieved();
- MapRequest mapRequest = createMapRequest(LispAFIConvertor.asIPAfiAddress(eid));
+ MapRequest mapRequest = createMapRequest(LispAddressUtil.asIpv4PrefixEid(eid));
MapRequestBuilder builder = new MapRequestBuilder(mapRequest);
builder.setPitr(true);
mapRequest = builder.build();
Code Review / lispflowmapping.git / blobdiff