/*
- * Copyright (c) 2014 Contextream, Inc. and others. All rights reserved.
+ * Copyright (c) 2014, 2017 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,
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertNotNull;
+import static org.junit.Assert.assertNull;
import static org.junit.Assert.assertTrue;
import static org.junit.Assert.fail;
+import static org.opendaylight.lispflowmapping.integrationtest.MultiSiteScenarioUtil.SITE_A;
+import static org.opendaylight.lispflowmapping.integrationtest.MultiSiteScenarioUtil.SITE_A_SB;
+import static org.opendaylight.lispflowmapping.integrationtest.MultiSiteScenarioUtil.SITE_B;
+import static org.opendaylight.lispflowmapping.integrationtest.MultiSiteScenarioUtil.SITE_B_SB;
+import static org.opendaylight.lispflowmapping.integrationtest.MultiSiteScenarioUtil.SITE_C;
+import static org.opendaylight.lispflowmapping.integrationtest.MultiSiteScenarioUtil.SITE_C_RLOC_10;
+import static org.opendaylight.lispflowmapping.integrationtest.MultiSiteScenarioUtil.SITE_C_SB;
+import static org.opendaylight.lispflowmapping.integrationtest.MultiSiteScenarioUtil.SITE_C_WP_100_1_SB;
+import static org.opendaylight.lispflowmapping.integrationtest.MultiSiteScenarioUtil.SITE_C_WP_50_2_SB;
+import static org.opendaylight.lispflowmapping.integrationtest.MultiSiteScenarioUtil.SITE_D4;
+import static org.opendaylight.lispflowmapping.integrationtest.MultiSiteScenarioUtil.SITE_D5;
+import static org.opendaylight.lispflowmapping.integrationtest.MultiSiteScenarioUtil.SITE_D_DELETE_SB;
+import static org.opendaylight.lispflowmapping.integrationtest.MultiSiteScenarioUtil.SITE_D_WP_100_1_SB;
+import static org.opendaylight.lispflowmapping.integrationtest.MultiSiteScenarioUtil.SITE_D_WP_50_2_SB;
+import static org.opendaylight.lispflowmapping.integrationtest.MultiSiteScenarioUtil.SITE_E_SB;
import static org.ops4j.pax.exam.CoreOptions.composite;
import static org.ops4j.pax.exam.CoreOptions.maven;
import static org.ops4j.pax.exam.karaf.options.KarafDistributionOption.editConfigurationFilePut;
+import com.google.common.collect.Lists;
+import com.google.common.collect.Sets;
+import com.google.common.net.InetAddresses;
+import java.io.IOException;
import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.InetAddress;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
-
+import java.util.Set;
import javax.inject.Inject;
-
-//import org.codehaus.jettison.json.JSONException;
-//import org.codehaus.jettison.json.JSONObject;
-//import org.codehaus.jettison.json.JSONTokener;
import org.junit.After;
import org.junit.Assert;
import org.junit.Before;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.opendaylight.controller.mdsal.it.base.AbstractMdsalTestBase;
+import org.opendaylight.lispflowmapping.config.ConfigIni;
import org.opendaylight.lispflowmapping.implementation.LispMappingService;
+import org.opendaylight.lispflowmapping.interfaces.dao.SubKeys;
+import org.opendaylight.lispflowmapping.interfaces.dao.Subscriber;
import org.opendaylight.lispflowmapping.interfaces.lisp.IFlowMapping;
import org.opendaylight.lispflowmapping.interfaces.mappingservice.IMappingService;
-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.MapReplySerializer;
import org.opendaylight.lispflowmapping.lisp.serializer.MapRequestSerializer;
+import org.opendaylight.lispflowmapping.lisp.type.LispMessage;
+import org.opendaylight.lispflowmapping.lisp.type.MappingData;
+import org.opendaylight.lispflowmapping.lisp.util.ByteUtil;
+import org.opendaylight.lispflowmapping.lisp.util.LispAddressStringifier;
+import org.opendaylight.lispflowmapping.lisp.util.LispAddressUtil;
import org.opendaylight.lispflowmapping.type.sbplugin.IConfigLispSouthboundPlugin;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.IpAddress;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.IpPrefix;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.Ipv4Address;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.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;
+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.lisp.address.types.rev151105.lisp.address.address.source.dest.key.SourceDestKeyBuilder;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.yang.types.rev130715.MacAddress;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.inet.binary.types.rev160303.Ipv4AddressBinary;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.binary.address.types.rev160504.Ipv4PrefixBinaryAfi;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.binary.address.types.rev160504.augmented.lisp.address.address.Ipv4BinaryBuilder;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.binary.address.types.rev160504.augmented.lisp.address.address.Ipv4PrefixBinaryBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.AddMapping;
import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.GotMapNotify;
import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.GotMapReply;
import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.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.MappingKeepAlive;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.MessageType;
import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.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.SiteId;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.XtrId;
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.eid.container.Eid;
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.authkey.container.MappingAuthkey;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.mapping.authkey.container.MappingAuthkeyBuilder;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.mapping.record.container.MappingRecord;
import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.mapping.record.container.MappingRecord.Action;
import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.mapping.record.container.MappingRecordBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.mapping.record.list.MappingRecordItem;
import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.maprequestnotification.MapRequestBuilder;
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.lisp.address.types.rev151105.lisp.address.address.source.dest.key.SourceDestKeyBuilder;
-import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.yang.types.rev100924.MacAddress;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.mappingservice.rev150906.MappingOrigin;
import org.ops4j.pax.exam.Option;
import org.ops4j.pax.exam.junit.PaxExam;
-import org.ops4j.pax.exam.util.Filter;
import org.ops4j.pax.exam.karaf.options.LogLevelOption.LogLevel;
import org.ops4j.pax.exam.options.MavenUrlReference;
import org.ops4j.pax.exam.spi.reactors.ExamReactorStrategy;
import org.ops4j.pax.exam.spi.reactors.PerClass;
+import org.ops4j.pax.exam.util.Filter;
import org.osgi.framework.Bundle;
import org.osgi.framework.BundleContext;
import org.osgi.framework.InvalidSyntaxException;
public class MappingServiceIntegrationTest extends AbstractMdsalTestBase {
private static final Logger LOG = LoggerFactory.getLogger(MappingServiceIntegrationTest.class);
+ /**
+ * Defines how many attempt to create instance of DatagramSocket will be done before giving up.
+ */
+ private static final int NUM_OF_ATTEMPTS_TO_CREATE_SOCKET = 2;
+
private byte[] mapRequestPacket;
private byte[] mapRegisterPacketWithNotify;
private byte[] mapRegisterPacketWithoutNotify;
String lispBindAddress = "127.0.0.1";
- String ourAddress = "127.0.0.2";
+ static final String ourAddress = "127.0.0.2";
private Rloc locatorEid;
private DatagramSocket socket;
private byte[] mapRegisterPacketWithAuthenticationAndMapNotify;
public static final String ODL = "org.opendaylight.controller";
public static final String YANG = "org.opendaylight.yangtools";
- public static final String JERSEY = "com.sun.jersey";
+ private static final int MULTI_SITE_SLEEP_TIME = 1;
private static final int MAX_NOTIFICATION_RETRYS = 20;
-
- @Override
- public String getModuleName() {
- return "mappingservice-impl";
- }
-
- @Override
- public String getInstanceName() {
- return "mappingservice-default";
- }
+ private static final MappingAuthkey NULL_AUTH_KEY = new MappingAuthkeyBuilder().setKeyType(0).build();
// This is temporary, since the properties in the pom file are not picked up
@Override
public String getKarafDistro() {
return maven()
.groupId("org.opendaylight.lispflowmapping")
- .artifactId("distribution-karaf")
+ .artifactId("lispflowmapping-karaf")
.versionAsInProject()
.type("zip")
.getURL();
public MavenUrlReference getFeatureRepo() {
return maven()
.groupId("org.opendaylight.lispflowmapping")
- .artifactId("features-lispflowmapping")
+ .artifactId("features4-lispflowmapping")
.classifier("features")
.type("xml")
.versionAsInProject();
@Override
public Option getLoggingOption() {
Option option = editConfigurationFilePut(ORG_OPS4J_PAX_LOGGING_CFG,
- logConfiguration(MappingServiceIntegrationTest.class),
+ "log4j.logger.org.opendaylight.lispflowmapping",
LogLevel.DEBUG.name());
option = composite(option, super.getLoggingOption());
return option;
if (socket != null) {
socket.close();
}
-// if (connection != null) {
-// connection.disconnect();
-// }
+ // reset mapping record validity to default value
+ ConfigIni.getInstance().setRegistrationValiditySb(200000L);
}
@Before
public void before() throws Exception {
areWeReady();
+ mapService.setLookupPolicy(IMappingService.LookupPolicy.NB_FIRST);
+ mapService.setMappingMerge(false);
+ ConfigIni.getInstance().setSmrRetryCount(1);
+
locatorEid = LispAddressUtil.asIpv4Rloc("4.3.2.1");
socket = initSocket(socket, LispMessage.PORT_NUM);
// 255/0
//
- mapRegisterPacketWithAuthenticationAndMapNotify = extractWSUdpByteArray(new String("0000 00 50 56 ee d1 4f 00 0c 29 7a ce 79 08 00 45 00 " //
+ mapRegisterPacketWithAuthenticationAndMapNotify = extractWSUdpByteArray(new String(
+ "0000 00 50 56 ee d1 4f 00 0c 29 7a ce 79 08 00 45 00 " //
+ "0010 00 5c 00 00 40 00 40 11 d4 db c0 a8 88 0a 80 df "
+ "0020 9c 23 d6 40 10 f6 00 48 59 a4 38 00 01 01 00 00 "
+ "0030 00 00 00 00 00 00 00 01 00 14 0e a4 c6 d8 a4 06 "
// 255/0
//
- mapRegisterPacketWithNotify = extractWSUdpByteArray(new String("0000 00 50 56 ee d1 4f 00 0c 29 7a ce 79 08 00 45 00 " //
+ mapRegisterPacketWithNotify = extractWSUdpByteArray(new String(
+ "0000 00 50 56 ee d1 4f 00 0c 29 7a ce 79 08 00 45 00 " //
+ "0010 00 5c 00 00 40 00 40 11 d4 db c0 a8 88 0a 80 df "
+ "0020 9c 23 d6 40 10 f6 00 48 59 a4 38 00 01 01 00 00 "
+ "0030 00 00 00 00 00 07 00 00 00 14 0e a4 c6 d8 a4 06 "
// 255/0
//
- mapRegisterPacketWithoutNotify = extractWSUdpByteArray(new String("0000 00 50 56 ee d1 4f 00 0c 29 7a ce 79 08 00 45 00 " //
+ mapRegisterPacketWithoutNotify = extractWSUdpByteArray(new String(
+ "0000 00 50 56 ee d1 4f 00 0c 29 7a ce 79 08 00 45 00 " //
+ "0010 00 5c 00 00 40 00 40 11 d4 db c0 a8 88 0a 80 df "
+ "0020 9c 23 d6 40 10 f6 00 48 59 a4 38 00 00 01 00 00 "
+ "0030 00 00 00 00 00 07 00 00 00 14 0e a4 c6 d8 a4 06 "
@Test
public void testLCAFs() throws Exception {
- //registerAndQuery__SrcDestLCAF();
- //registerAndQuery__SrcDestLCAFOverlap();
- //registerAndQuery__KeyValueLCAF();
+ registerAndQuery__SrcDestLCAF();
+ registerAndQuery__SrcDestLCAFOverlap();
+ registerAndQuery__KeyValueLCAF();
//registerAndQuery__ListLCAF();
//registerAndQuery__ApplicationData();
//registerAndQuery__TrafficEngineering();
@Test
public void testTimeOuts() throws Exception {
+ timedOutMappingRecord();
mapRequestMapRegisterAndMapRequestTestTimeout();
//mapRequestMapRegisterAndMapRequestTestNativelyForwardTimeoutResponse(); TODO commented because it needs NB
}
@Test
public void testSmr() throws Exception {
registerQueryRegisterWithSmr();
+ testRepeatedSmr();
+ }
+
+ @Test
+ public void testMultiSite() throws Exception {
+ testMultiSiteScenarioA();
+ testMultiSiteScenarioB();
+ }
+
+ @Test
+ public void testNegativePrefix_gapIntersection() throws UnknownHostException {
+ insertMappings();
+ testGapIntersection();
+
+ insertMappings();
+ testMultipleMappings();
+ }
+
+ private void testRepeatedSmr() throws SocketTimeoutException, UnknownHostException {
+ cleanUP();
+ long timeout = ConfigIni.getInstance().getSmrTimeout();
+ ConfigIni.getInstance().setSmrRetryCount(5);
+
+ final InstanceIdType iid = new InstanceIdType(1L);
+ final Eid eid1 = LispAddressUtil.asIpv4Eid("1.1.1.1", 1L);
+ final int expectedSmrs1 = 2;
+ final int expectedSmrs2 = 3;
+
+ /* set auth */
+ final Eid eid = LispAddressUtil.asIpv4PrefixBinaryEid("0.0.0.0/0", iid);
+ mapService.addAuthenticationKey(eid, NULL_AUTH_KEY);
+
+ /* add subscribers */
+ final String subscriberSrcRloc1 = "127.0.0.3";
+ final String subscriberSrcRloc2 = "127.0.0.4";
+ final Set<Subscriber> subscriberSet1 = Sets.newHashSet(newSubscriber(eid1, subscriberSrcRloc1),
+ newSubscriber(eid1, subscriberSrcRloc2));
+ mapService.addData(MappingOrigin.Southbound, eid1, SubKeys.SUBSCRIBERS, subscriberSet1);
+
+ final SocketReader reader1 = startSocketReader(subscriberSrcRloc1, 15000);
+ final SocketReader reader2 = startSocketReader(subscriberSrcRloc2, 15000);
+ sleepForSeconds(1);
+
+ /* add mapping */
+ final MappingRecord mapping1 = new MappingRecordBuilder()
+ .setEid(eid1).setTimestamp(System.currentTimeMillis()).setRecordTtl(1440).build();
+ mapService.addMapping(MappingOrigin.Northbound, eid1, null, new MappingData(mapping1));
+
+ sleepForMilliseconds((timeout * expectedSmrs1) - (timeout / 2));
+ final List<MapRequest> requests1 = processSmrPackets(reader1, subscriberSrcRloc1, expectedSmrs1);
+ final MapReply mapReply1 = lms.handleMapRequest(
+ new MapRequestBuilder(requests1.get(0))
+ .setItrRloc(Lists.newArrayList(new ItrRlocBuilder()
+ .setRloc(LispAddressUtil.asIpv4Rloc(subscriberSrcRloc1)).build()))
+ .setEidItem(Lists.newArrayList(new EidItemBuilder().setEid(eid1).build()))
+ .setSmrInvoked(true)
+ .setSmr(false).build());
+
+ // sleep to get 1 extra smr request
+ sleepForMilliseconds(timeout * 1);
+ final List<MapRequest> requests2 = processSmrPackets(reader2, subscriberSrcRloc2, expectedSmrs2);
+ final MapReply mapReply2 = lms.handleMapRequest(
+ new MapRequestBuilder(requests2.get(0))
+ .setItrRloc(Lists.newArrayList(new ItrRlocBuilder()
+ .setRloc(LispAddressUtil.asIpv4Rloc(subscriberSrcRloc2)).build()))
+ .setEidItem(Lists.newArrayList(new EidItemBuilder().setEid(eid1).build()))
+ .setSmrInvoked(true)
+ .setSmr(false).build());
+
+ sleepForSeconds(3);
+ assertEquals(expectedSmrs1, requests1.size());
+ assertEquals(expectedSmrs2, requests2.size());
+ assertEquals((long) mapReply1.getNonce(), (long) requests1.get(0).getNonce());
+ assertEquals((long) mapReply2.getNonce(), (long) requests2.get(0).getNonce());
+ assertNextBufferEmpty(reader1);
+ assertNextBufferEmpty(reader2);
+
+ reader1.stopReading();
+ reader2.stopReading();
+ }
+
+ private SocketReader startSocketReader(String address, int timeout) {
+ DatagramSocket receivingSocket = null;
+
+ try {
+ receivingSocket = new DatagramSocket(new InetSocketAddress(address, LispMessage.PORT_NUM));
+ } catch (SocketException e) {
+ LOG.error("Can't initialize socket for {}", address, e);
+ }
+ return SocketReader.startReadingInStandaloneThread(receivingSocket, timeout);
+ }
+
+ private List<MapRequest> processSmrPackets(SocketReader reader, String address, int expectedSmrs) {
+ InetAddress inetAddress = null;
+ try {
+ inetAddress = InetAddress.getByName(address);
+ } catch (UnknownHostException e) {
+ LOG.error("Unknown address {}.", address, e);
+ }
+
+ final List<MapRequest> requests = Lists.newArrayList();
+ byte[][] buffers = reader.getBuffers(expectedSmrs);
+ for (byte[] buf : buffers) {
+ MapRequest request = MapRequestSerializer.getInstance().deserialize(ByteBuffer.wrap(buf), inetAddress);
+ requests.add(request);
+ }
+ return requests;
+ }
+
+ private void assertNextBufferEmpty(SocketReader socketReader) {
+ assertTrue(isArrayEmpty(socketReader.getBuffers(1)[0]));
+ }
+
+ private boolean isArrayEmpty(byte[] byteArray) {
+ for (byte b : byteArray) {
+ if (b != 0) {
+ return false;
+ }
+ }
+ return true;
+ }
+
+ private static Subscriber newSubscriber(Eid srcEid, String srcRlocIp) {
+ final byte[] addressBinary = InetAddresses.forString(srcRlocIp).getAddress();
+ final int timeout = 5;
+ final Rloc srcRloc = new RlocBuilder().setAddress(new Ipv4BinaryBuilder()
+ .setIpv4Binary(new Ipv4AddressBinary(addressBinary)).build()).build();
+
+ return new Subscriber(srcRloc, srcEid, timeout);
+ }
+
+ private void testMultipleMappings() throws UnknownHostException {
+ final InstanceIdType iid = new InstanceIdType(1L);
+ final String prefix1 = "1.1.127.10/32"; // prefix from the intersection of NB and SB gaps
+ final String prefix2 = "1.1.200.255/32"; // prefix with existing mapping in NB
+ final String prefix3 = "1.3.255.255/32";
+
+ final MapRequest mapRequest = new MapRequestBuilder().setSmrInvoked(false).setEidItem(Lists.newArrayList(
+ new EidItemBuilder().setEid(LispAddressUtil.asIpv4PrefixBinaryEid(prefix1, iid))
+ .build(),
+ new EidItemBuilder().setEid(LispAddressUtil.asIpv4PrefixBinaryEid(prefix2, iid))
+ .build(),
+ new EidItemBuilder().setEid(LispAddressUtil.asIpv4PrefixBinaryEid(prefix3, iid))
+ .build()))
+ .build();
+ final MapReply mapReply = lms.handleMapRequest(mapRequest);
+
+ // expected result
+ final String resultPrefix1 = "1.1.64.0";
+ final Address resultNegMapping1 = new Ipv4PrefixBinaryBuilder()
+ .setIpv4AddressBinary(new Ipv4AddressBinary(InetAddress.getByName(resultPrefix1).getAddress()))
+ .setIpv4MaskLength((short) 18).build();
+
+ final String resultPrefix2 = "1.1.128.0";
+ final Address resultMapping2 = new Ipv4PrefixBinaryBuilder()
+ .setIpv4AddressBinary(new Ipv4AddressBinary(InetAddress.getByName(resultPrefix2).getAddress()))
+ .setIpv4MaskLength((short) 17).build();
+
+ final String resultPrefix3 = "1.3.0.0";
+ final Address resultNegMapping3 = new Ipv4PrefixBinaryBuilder()
+ .setIpv4AddressBinary(new Ipv4AddressBinary(InetAddress.getByName(resultPrefix3).getAddress()))
+ .setIpv4MaskLength((short) 16).build();
+
+ assertEquals(resultNegMapping1, mapReply.getMappingRecordItem().get(0).getMappingRecord().getEid()
+ .getAddress());
+ assertEquals(resultMapping2, mapReply.getMappingRecordItem().get(1).getMappingRecord().getEid()
+ .getAddress());
+ assertEquals(resultNegMapping3, mapReply.getMappingRecordItem().get(2).getMappingRecord().getEid()
+ .getAddress());
+ }
+
+ /**
+ * Tests a negative mapping from an intersection of gaps in northbound and southbound.
+ */
+ private void testGapIntersection() throws UnknownHostException {
+ final InstanceIdType iid = new InstanceIdType(1L);
+
+ // request an Eid from a gap between mappings
+ final MapRequest mapRequest = new MapRequestBuilder().setSmrInvoked(false).setEidItem(Lists.newArrayList(
+ new EidItemBuilder().setEid(LispAddressUtil.asIpv4PrefixBinaryEid("1.1.127.10/32", iid))
+ .build()))
+ .build();
+ final MapReply mapReply = lms.handleMapRequest(mapRequest);
+
+ // expected negative mapping
+ final Address resultNegMapping = new Ipv4PrefixBinaryBuilder()
+ .setIpv4AddressBinary(new Ipv4AddressBinary(InetAddress.getByName("1.1.64.0").getAddress()))
+ .setIpv4MaskLength((short) 18).build();
+ assertEquals(resultNegMapping, mapReply.getMappingRecordItem().get(0).getMappingRecord().getEid()
+ .getAddress());
+ }
+
+ private void insertMappings() {
+ cleanUP();
+ mapService.setLookupPolicy(IMappingService.LookupPolicy.NB_AND_SB);
+
+ final InstanceIdType iid = new InstanceIdType(1L);
+ final String prefixNbLeft = "1.2.0.0/16";
+ final String prefixNbRight = "1.1.128.0/17";
+ final String prefixSbLeft = "1.1.32.0/19";
+ final String prefixSbRight = "1.0.0.0/8";
+
+ final MappingRecord mapRecordNbLeft = newMappingRecord(prefixNbLeft, iid);
+ final MappingRecord mapRecordNbRight = newMappingRecord(prefixNbRight, iid);
+ final MappingRecord mapRecordSbLeft = newMappingRecord(prefixSbLeft, iid);
+ final MappingRecord mapRecordSbRight = newMappingRecord(prefixSbRight, iid);
+
+ /* set auth */
+ final Eid eid = LispAddressUtil.asIpv4PrefixBinaryEid("0.0.0.0/0", iid);
+ mapService.addAuthenticationKey(eid, NULL_AUTH_KEY);
+
+ mapService.addMapping(MappingOrigin.Northbound, mapRecordNbLeft.getEid(), null,
+ new MappingData(mapRecordNbLeft));
+ mapService.addMapping(MappingOrigin.Northbound, mapRecordNbRight.getEid(), null,
+ new MappingData(mapRecordNbRight));
+ mapService.addMapping(MappingOrigin.Southbound, mapRecordSbLeft.getEid(), null,
+ new MappingData(mapRecordSbLeft, System.currentTimeMillis()));
+ mapService.addMapping(MappingOrigin.Southbound, mapRecordSbRight.getEid(), null,
+ new MappingData(mapRecordSbRight, System.currentTimeMillis()));
+
+ restartSocket();
+ sleepForSeconds(2);
+ }
+
+ /**
+ * Creates a new MappingRecord object.
+ *
+ * @param prefix The Eid prefix
+ * @param iid VNI
+ * @return new MappingRecord object
+ */
+ private MappingRecord newMappingRecord(String prefix, InstanceIdType iid) {
+ final Eid prefixBinary = LispAddressUtil.asIpv4PrefixBinaryEid(prefix, iid);
+ return new MappingRecordBuilder()
+ .setEid(prefixBinary)
+ .setLocatorRecord(Lists.newArrayList(new LocatorRecordBuilder()
+ .setRloc(LispAddressUtil.asIpv4Rloc("2.2.2.2"))
+ .setLocatorId("loc_id")
+ .setPriority((short) 1).build()))
+ .setTimestamp(System.currentTimeMillis())
+ .setRecordTtl(1440).build();
+ }
+
+ /**
+ * TEST SCENARIO A
+ */
+ public void testMultiSiteScenarioA() throws IOException {
+ cleanUP();
+ ConfigIni.getInstance().setSmrRetryCount(1);
+
+ final MultiSiteScenario multiSiteScenario = new MultiSiteScenario(mapService, lms);
+ multiSiteScenario.setCommonAuthentication();
+
+ restartSocket();
+ final SocketReader socketReader = SocketReader.startReadingInStandaloneThread(socket);
+
+ //TEST CASE 1
+ multiSiteScenario.storeSouthboundMappings(false, SITE_A, SITE_B, SITE_C, SITE_D4, SITE_D5);
+ multiSiteScenario.storeNorthMappingSrcDst(SITE_B, SITE_C);
+ multiSiteScenario.storeNorthMappingNegative(SITE_C, Action.Drop);
+ sleepForSeconds(MULTI_SITE_SLEEP_TIME);
+ multiSiteScenario.assertPingWorks(SITE_A, 5, SITE_B, 4);
+ multiSiteScenario.assertPingWorks(SITE_B, 5, SITE_C, 4);
+ multiSiteScenario.assertPingFails(SITE_A, 1, SITE_C, 4);
+
+ //TEST CASE 2
+ //following action should trigger generatting of SMR messages:
+ // 1) 192.0.2.5/32
+ // 2) 192.0.1.1/32
+ multiSiteScenario.storeNorthMappingSrcDst(SITE_A, SITE_C);
+ sleepForSeconds(MULTI_SITE_SLEEP_TIME);
+ multiSiteScenario.checkSMR(socketReader, SITE_C.getEidPrefix(), SITE_B.getHost(5), SITE_A.getHost(1));
+ multiSiteScenario.assertPingWorks(SITE_A, 5, SITE_C, 4);
+ multiSiteScenario.assertPingWorks(SITE_B, 5, SITE_C, 4);
+ multiSiteScenario.assertPingFails(SITE_D4, 5, SITE_C, 4);
+
+ //TEST CASE 3
+ // following action should trigger generatting of SMR messages:
+ // 1) 192.0.2.5/32
+ // 2) 192.0.1.1/32
+ // 3) 192.0.1.5/32
+ // 4) 192.0.4.5/32
+ multiSiteScenario.deleteNorthMappingNegative(SITE_C);
+ sleepForSeconds(MULTI_SITE_SLEEP_TIME);
+ multiSiteScenario.checkSMR(socketReader, SITE_C.getEidPrefix(), SITE_B.getHost(5), SITE_A.getHost(1), SITE_A
+ .getHost(5),
+ SITE_D4.getHost(5));
+ multiSiteScenario.assertPingWorks(SITE_D4, 5, SITE_C, 4);
+
+ //TEST CASE 4
+ // following action should trigger generatting of SMR messages:
+ // 1) 192.0.4.5/32
+ multiSiteScenario.storeNorthMappingSrcDst(SITE_B, SITE_C_RLOC_10);
+ sleepForSeconds(MULTI_SITE_SLEEP_TIME);
+ multiSiteScenario.checkSMR(socketReader, SITE_C.getEidPrefix(), SITE_D4.getHost(5));
+ //way of testing ping - get RLOC for mapping src-dst and compare it with awaited value doesn't test
+ //that ping won't be successfull
+ multiSiteScenario.assertPingFails(SITE_B, 5, SITE_C, 4);
+
+ //TEST CASE 5
+ // following action should trigger generatting of SMR messages:
+ // 1) 192.0.4.5/32
+ // 2) 192.0.2.5/32
+ multiSiteScenario.storeNorthMappingNegative(SITE_C, Action.Drop);
+ sleepForSeconds(MULTI_SITE_SLEEP_TIME);
+ multiSiteScenario.checkSMR(socketReader, SITE_C.getEidPrefix(), SITE_D4.getHost(5), SITE_B.getHost(5));
+ multiSiteScenario.assertPingFails(SITE_D4, 5, SITE_C, 4);
+
+ //TEST CASE 6
+ multiSiteScenario.assertPingFails(SITE_D5, 5, SITE_C, 3);
+
+ //TEST CASE 7
+ multiSiteScenario.deleteNorthMapingSrcDst(SITE_A, SITE_C);
+ sleepForSeconds(MULTI_SITE_SLEEP_TIME);
+ // following action should trigger generatting of SMR messages:
+ // 1) 192.0.4.5/32
+ // 2) 192.0.2.5/32
+ // 3) 192.0.5.5/32
+ multiSiteScenario.checkSMR(socketReader, SITE_C.getEidPrefix(), SITE_D5.getHost(5), SITE_D4.getHost(5),
+ SITE_B.getHost(5));
+
+ // following action should trigger generatting of SMR messages:
+ // 1) 192.0.4.5/32
+ // 2) 192.0.2.5/32
+ // 3) 192.0.5.5/32
+ multiSiteScenario.storeNorthMappingSrcDst(SITE_B, SITE_C);
+ sleepForSeconds(MULTI_SITE_SLEEP_TIME);
+ multiSiteScenario.checkSMR(socketReader, SITE_C.getEidPrefix(), SITE_D5.getHost(5), SITE_D4.getHost(5),
+ SITE_B.getHost(5));
+
+ multiSiteScenario.assertPingWorks(SITE_A, 5, SITE_B, 4);
+ multiSiteScenario.assertPingWorks(SITE_B, 5, SITE_C, 4);
+ multiSiteScenario.assertPingFails(SITE_A, 1, SITE_C, 4);
+
+ //TEST CASE 8
+ // following action should trigger generatting of SMR messages:
+ // 1) 192.0.4.5/32
+ // 2) 192.0.2.5/32
+ // 3) 192.0.5.5/32
+ // 4) 192.0.1.1/32
+ multiSiteScenario.deleteNorthMapingSrcDst(SITE_B, SITE_C);
+ sleepForSeconds(MULTI_SITE_SLEEP_TIME);
+ multiSiteScenario.checkSMR(socketReader, SITE_C.getEidPrefix(), SITE_D5.getHost(5), SITE_D4.getHost(5),
+ SITE_B.getHost(5),
+ SITE_A.getHost(1));
+ multiSiteScenario.assertPingWorks(SITE_A, 5, SITE_B, 4);
+ multiSiteScenario.assertPingFails(SITE_B, 5, SITE_C, 4);
+ multiSiteScenario.assertPingFails(SITE_A, 1, SITE_C, 4);
+
+ //TEST CASE 9
+ // following action should trigger generatting of SMR messages:
+ // 1) 192.0.4.5/32
+ // 2) 192.0.2.5/32
+ // 3) 192.0.5.5/32
+ // 4) 192.0.1.1/32
+ multiSiteScenario.deleteNorthMappingNegative(SITE_C);
+ sleepForSeconds(MULTI_SITE_SLEEP_TIME);
+ multiSiteScenario.checkSMR(socketReader, SITE_C.getEidPrefix(), SITE_D5.getHost(5), SITE_D4.getHost(5),
+ SITE_B.getHost(5),
+ SITE_A.getHost(1));
+ multiSiteScenario.assertPingWorks(SITE_A, 5, SITE_B, 4);
+ multiSiteScenario.assertPingWorks(SITE_B, 5, SITE_C, 4);
+ multiSiteScenario.assertPingWorks(SITE_A, 5, SITE_C, 4);
+
+ socketReader.stopReading();
+
+ }
+
+ /**
+ * TEST SCENARIO B
+ */
+ public void testMultiSiteScenarioB() throws IOException {
+ cleanUP();
+
+ final MultiSiteScenario multiSiteScenario = new MultiSiteScenario(mapService, lms);
+ multiSiteScenario.setCommonAuthentication();
+
+ restartSocket();
+ final SocketReader socketReader = SocketReader.startReadingInStandaloneThread(socket);
+
+ mapService.setLookupPolicy(IMappingService.LookupPolicy.NB_AND_SB);
+ mapService.setMappingMerge(true);
+
+ //TEST CASE 1
+ multiSiteScenario.storeSouthboundMappings(true, SITE_A_SB, SITE_B_SB, SITE_C_WP_100_1_SB, SITE_D_WP_100_1_SB,
+ SITE_E_SB);
+ multiSiteScenario.storeNorthMappingIpPrefix(SITE_A_SB);
+ multiSiteScenario.storeNorthMappingIpPrefix(SITE_B_SB);
+ multiSiteScenario.storeNorthMappingIpPrefix(SITE_C_WP_50_2_SB, SITE_D_WP_50_2_SB);
+ sleepForSeconds(MULTI_SITE_SLEEP_TIME);
+ multiSiteScenario.assertPingWorks(SITE_A_SB, 5, SITE_C_WP_50_2_SB, 4, SITE_D_WP_50_2_SB);
+ multiSiteScenario.assertPingWorks(SITE_B_SB, 5, SITE_C_WP_50_2_SB, 4, SITE_D_WP_50_2_SB);
+
+ //TEST CASE 2
+ // following action should trigger generatting of SMR messages:
+ // 1) 192.0.2.5/32
+ // 2) 192.0.1.5/32
+ multiSiteScenario.storeNorthMappingSrcDst(SITE_A_SB, SITE_C_WP_50_2_SB, SITE_D_WP_50_2_SB);
+ sleepForSeconds(MULTI_SITE_SLEEP_TIME);
+ multiSiteScenario.checkSMR(socketReader, SITE_C.getEidPrefix(), SITE_B_SB.getHost(5), SITE_A_SB.getHost(5));
+
+ // following action should trigger generatting of SMR messages:
+ // 1) 192.0.2.5/32
+ // 2) 192.0.1.5/32
+ multiSiteScenario.storeNorthMappingNegative(SITE_C_SB, Action.Drop);
+ sleepForSeconds(MULTI_SITE_SLEEP_TIME);
+ multiSiteScenario.checkSMR(socketReader, SITE_C.getEidPrefix(), SITE_B_SB.getHost(5), SITE_A_SB.getHost(5));
+
+ multiSiteScenario.assertPingWorks(SITE_A_SB, 5, SITE_C_WP_50_2_SB, 4, SITE_D_WP_50_2_SB);
+ multiSiteScenario.assertPingFails(SITE_B_SB, 5, SITE_C_SB, 4);
+
+
+ //TEST CASE 3
+ // following action should trigger generatting of SMR messages:
+ // 1) 192.0.2.5/32
+ // 2) 192.0.1.5/32
+ multiSiteScenario.storeNorthMappingSrcDst(SITE_A_SB, SITE_C_WP_50_2_SB);
+ sleepForSeconds(MULTI_SITE_SLEEP_TIME);
+ multiSiteScenario.checkSMR(socketReader, SITE_C.getEidPrefix(), SITE_B_SB.getHost(5), SITE_A_SB.getHost(5));
+ multiSiteScenario.assertPingWorks(SITE_A_SB, 5, SITE_C_WP_50_2_SB, 4);
+
+ //TEST CASE 4
+ multiSiteScenario.storeNorthMappingSrcDst(SITE_B_SB, SITE_C_WP_50_2_SB, SITE_D_WP_50_2_SB);
+ sleepForSeconds(MULTI_SITE_SLEEP_TIME);
+ // following action should trigger generatting of SMR messages:
+ // 1) 192.0.2.5/32
+ // 2) 192.0.1.5/32
+ multiSiteScenario.checkSMR(socketReader, SITE_C.getEidPrefix(), SITE_B_SB.getHost(5), SITE_A_SB.getHost(5));
+ multiSiteScenario.assertPingWorks(SITE_B_SB, 5, SITE_C_WP_50_2_SB, 4, SITE_D_WP_50_2_SB);
+
+ //TEST CASE 5
+ multiSiteScenario.deleteSouthboundMappings(SITE_D_DELETE_SB);
+ sleepForSeconds(MULTI_SITE_SLEEP_TIME);
+ // following action should trigger generatting of SMR messages:
+ // 1) 192.0.2.5/32
+ // 2) 192.0.1.5/32
+ multiSiteScenario.checkSMR(socketReader, SITE_C.getEidPrefix(), SITE_B_SB.getHost(5), SITE_A_SB.getHost(5));
+
+ multiSiteScenario.assertPingWorks(SITE_B_SB, 5, SITE_C_WP_50_2_SB, 4);
+
+ //TEST CASE 6
+ multiSiteScenario.deleteNorthMapingSrcDst(SITE_A_SB, SITE_C_WP_50_2_SB);
+ sleepForSeconds(MULTI_SITE_SLEEP_TIME);
+ // following action should trigger generatting of SMR messages:
+ // 1) 192.0.2.5/32
+ // 2) 192.0.1.5/32
+ multiSiteScenario.checkSMR(socketReader, SITE_C.getEidPrefix(), SITE_B_SB.getHost(5), SITE_A_SB.getHost(5));
+
+ multiSiteScenario.deleteNorthMapingSrcDst(SITE_B_SB, SITE_C_WP_50_2_SB);
+ sleepForSeconds(MULTI_SITE_SLEEP_TIME);
+ multiSiteScenario.assertPingFails(SITE_B_SB, 5, SITE_C_WP_50_2_SB, 4);
+
+ socketReader.stopReading();
+
}
// ------------------------------- Simple Tests ---------------------------
public void mapRegisterWithMapNotify() throws SocketTimeoutException {
cleanUP();
+ mapService.addAuthenticationKey(LispAddressUtil.asIpv4PrefixBinaryEid("153.16.254.1/32"), NULL_AUTH_KEY);
+
+ sleepForSeconds(2);
sendPacket(mapRegisterPacketWithNotify);
MapNotify reply = receiveMapNotify();
assertEquals(7, reply.getNonce().longValue());
public void mapRegisterWithMapNotifyAndMapRequest() throws SocketTimeoutException {
cleanUP();
- Eid eid = LispAddressUtil.asIpv4PrefixEid("1.2.3.4/32");
+ Eid eid = LispAddressUtil.asIpv4PrefixBinaryEid("1.2.3.4/32");
MapReply mapReply = registerAddressAndQuery(eid);
public void mapRequestMapRegisterAndMapRequest() throws SocketTimeoutException {
cleanUP();
- Eid eid = LispAddressUtil.asIpv4PrefixEid("1.2.3.4/32");
+ Eid eid = LispAddressUtil.asIpv4PrefixBinaryEid("1.2.3.4/32");
+ mapService.addAuthenticationKey(eid, NULL_AUTH_KEY);
+ sleepForSeconds(1);
+
MapRequestBuilder mapRequestBuilder = new MapRequestBuilder();
mapRequestBuilder.setNonce((long) 4);
mapRequestBuilder.setSourceEid(new SourceEidBuilder().setEid(LispAddressUtil.getNoAddressEid()).build());
public void testMapRegisterDosntOverwritesOtherSubKeys() throws SocketTimeoutException {
cleanUP();
- Eid eid = LispAddressUtil.asIpv4PrefixEid("1.2.3.4/32");
+ Eid eid = LispAddressUtil.asIpv4PrefixBinaryEid("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")));
public void testMapRegisterOverwritesSameSubkey() throws SocketTimeoutException {
cleanUP();
- Eid eid = LispAddressUtil.asIpv4PrefixEid("1.2.3.4/32");
+ Eid eid = LispAddressUtil.asIpv4PrefixBinaryEid("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")));
public void testMapRegisterOverwritesNoSubkey() throws SocketTimeoutException {
cleanUP();
- mapService.setMappingOverwrite(true);
- Eid eid = LispAddressUtil.asIpv4PrefixEid("1.2.3.4/32");
+ mapService.setMappingMerge(false);
+ Eid eid = LispAddressUtil.asIpv4PrefixBinaryEid("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);
public void testMapRegisterDoesntOverwritesNoSubkey() throws SocketTimeoutException {
cleanUP();
- mapService.setMappingOverwrite(false);
- Eid eid = LispAddressUtil.asIpv4PrefixEid("1.2.3.4/32");
+ mapService.setMappingMerge(true);
+ Eid eid = LispAddressUtil.asIpv4PrefixBinaryEid("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.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();
+ 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(Eid eid, Rloc rloc1, Rloc rloc2)
throws SocketTimeoutException {
+ mapService.addAuthenticationKey(eid, NULL_AUTH_KEY);
+ sleepForSeconds(1);
MapRegister mb = createMapRegister(eid, rloc1);
- MapNotify mapNotify = lms.handleMapRegister(mb);
+ MapNotify mapNotify = lms.handleMapRegister(mb).getLeft();
MapRequest mr = createMapRequest(eid);
MapReply mapReply = lms.handleMapRequest(mr);
- assertEquals(mb.getMappingRecordItem().get(0).getMappingRecord().getLocatorRecord().get(0).getRloc(), mapReply.getMappingRecordItem().get(0).getMappingRecord()
- .getLocatorRecord().get(0).getRloc());
+ 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);
+ mapNotify = lms.handleMapRegister(mb).getLeft();
assertEquals(8, mapNotify.getNonce().longValue());
mr = createMapRequest(eid);
sendMapRequest(mr);
public void registerQueryRegisterWithSmr() throws SocketTimeoutException {
cleanUP();
lms.setShouldUseSmr(true);
+ mapService.addAuthenticationKey(LispAddressUtil.asIpv4PrefixBinaryEid("153.16.254.1/32"), NULL_AUTH_KEY);
+ sleepForSeconds(1);
sendPacket(mapRegisterPacketWithNotify);
receiveMapNotify();
sendPacket(mapRegisterPacketWithoutNotify);
ByteBuffer readBuf = ByteBuffer.wrap(receivePacket().getData());
- MapRequest smr = MapRequestSerializer.getInstance().deserialize(readBuf);
+ MapRequest smr = MapRequestSerializer.getInstance().deserialize(readBuf, null);
assertTrue(smr.isSmr());
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));
+ assertTrue(LispAddressUtil.asIpv4PrefixBinaryEid("1.2.3.4/32").equals(smrEid));
}
// --------------------- Northbound Tests ---------------------------
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) LispAddressUtil
+ 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
+ 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())
+ 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();
+ .setSrcAddress(new SrcAddressBuilder().setPrimitiveAddress(address1).build())
+ .setSrcMaskLength((short) mask1)
+ .setDstAddress(new DstAddressBuilder().setPrimitiveAddress(address2).build())
+ .setDstMaskLength((short) mask2).build();
String pass = "asdf";
lms.addAuthenticationKey(LispAddressUtil.toContainer(sourceDestAddress), mask1, pass);
// URL url = createGetKeyIPv4URL(address1, mask1);
URL url = createGetKeySourceDestURL(address1.getIpv4Address().getAfi(),
- ((LispIpv4Address) LispAddressUtil.toAFIfromPrimitive(sourceDestAddress.getSrcAddress().getPrimitiveAddress())).getIpv4Address().getValue(), sourceDestAddress.getSrcMaskLength(),
- ((LispIpv4Address) LispAddressUtil.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);
mapRequestBuilder.setPitr(false);
mapRequestBuilder.setEidItem(new ArrayList<EidItem>());
mapRequestBuilder.getEidItem().add(
- new EidRecordBuilder().setMask((short) mask).setLispAddressContainer(LispAddressUtil.toContainer(eid)).build());
+ new EidRecordBuilder().setMask((short) mask).setLispAddressContainer(
+ LispAddressUtil.toContainer(eid)).build());
MapReply mapReply = lms.handleMapRequest(mapRequestBuilder.build());
LispIpv4Address retrievedRloc = (LispIpv4Address) LispAddressUtil.toAFI(
- mapReply.getMappingRecordItem().get(0).getMappingRecord().getLocatorRecord().get(0).getLispAddressContainer());
+ mapReply.getMappingRecordItem().get(0).getMappingRecord().getLocatorRecord().get(0)
+ .getLispAddressContainer());
assertEquals(rloc.getIpv4Address().getValue(), retrievedRloc.getIpv4Address().getValue());
}
private String createMapRegisterJSON(String key, LispIpv4Address eid, int mask, LispIpv4Address rloc) {
- String jsonString = "{ " + "\"key\" : \"" + key + "\"," + "\"mapregister\" : " + "{ " + "\"proxyMapReply\" : false, "
- + "\"eidToLocatorRecords\" : " + "[ " + "{ " + "\"authoritative\" : true," + "\"prefixGeneric\" : " + "{ " + "\"ipAddress\" : \""
- + eid.getIpv4Address().getValue() + "\"," + "\"afi\" : " + eid.getAfi().shortValue() + "}," + "\"mapVersion\" : 0,"
- + "\"maskLength\" : " + mask + ", " + "\"action\" : \"NoAction\"," + "\"locators\" : " + "[ " + "{ " + "\"multicastPriority\" : 1,"
- + "\"locatorGeneric\" : " + "{ " + "\"ipAddress\" : \"" + rloc.getIpv4Address().getValue() + "\"," + "\"afi\" : "
- + rloc.getAfi().shortValue() + "}, " + "\"routed\" : true," + "\"multicastWeight\" : 50," + "\"rlocProbed\" : false, "
- + "\"localLocator\" : false, " + "\"priority\" : 1, " + "\"weight\" : 50 " + "} " + "], " + "\"recordTtl\" : 100" + "} " + "], "
+ String jsonString = "{ " + "\"key\" : \"" + key + "\"," + "\"mapregister\" : " + "{ "
+ + "\"proxyMapReply\" : false, "
+ + "\"eidToLocatorRecords\" : " + "[ " + "{ " + "\"authoritative\" : true," + "\"prefixGeneric\" : "
+ + "{ " + "\"ipAddress\" : \""
+ + eid.getIpv4Address().getValue() + "\"," + "\"afi\" : " + eid.getAfi().shortValue() + "},"
+ + "\"mapVersion\" : 0,"
+ + "\"maskLength\" : " + mask + ", " + "\"action\" : \"NoAction\"," + "\"locators\" : " + "[ " + "{ "
+ + "\"multicastPriority\" : 1,"
+ + "\"locatorGeneric\" : " + "{ " + "\"ipAddress\" : \"" + rloc.getIpv4Address().getValue() + "\","
+ + "\"afi\" : "
+ + rloc.getAfi().shortValue() + "}, " + "\"routed\" : true," + "\"multicastWeight\" : 50,"
+ + "\"rlocProbed\" : false, "
+ + "\"localLocator\" : false, " + "\"priority\" : 1, " + "\"weight\" : 50 " + "} " + "], "
+ + "\"recordTtl\" : 100" + "} " + "], "
+ "\"nonce\" : 3," + "\"keyId\" : 0 " + "} " + "}";
return jsonString;
etlr.getLocatorRecord().add(record.build());
mapRegister.setMappingRecordItem(new ArrayList<MappingRecordItem>());
mapRegister.getMappingRecordItem().add(new MappingRecordItemBuilder().setMappingRecord(etlr.build()).build());
- lms.handleMapRegister(mapRegister.build(), false);
+ lms.handleMapRegister(mapRegister.build());
// Get mapping using NB interface. No IID used
URL url = createGetMappingIPv4URL(0, eid, mask);
JSONObject json = new JSONObject(jt);
// With just one locator, locators is not a JSONArray
- String rlocRetrieved = json.getJSONArray("locators").getJSONObject(0).getJSONObject("locatorGeneric").getString("ipAddress");
+ String rlocRetrieved = json.getJSONArray("locators").getJSONObject(0).getJSONObject("locatorGeneric")
+ .getString("ipAddress");
assertEquals(rloc.getIpv4Address().getValue(), rlocRetrieved);
etlr.getLocatorRecord().add(record.build());
mapRegister.setMappingRecordItem(new ArrayList<MappingRecordItem>());
mapRegister.getMappingRecordItem().add(new MappingRecordItemBuilder().setMappingRecord(etlr.build()).build());
- lms.handleMapRegister(mapRegister.build(), false);
+ lms.handleMapRegister(mapRegister.build());
// Delete mapping using NB interface. No IID used
URL url = createDeleteMappingIPv4URL(0, eid, mask);
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) LispAddressUtil
+ 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
+ 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())
+ 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();
+ .setSrcAddress(new SrcAddressBuilder().setPrimitiveAddress(
+ address1).build()).setSrcMaskLength((short) mask1)
+ .setDstAddress(new DstAddressBuilder().setPrimitiveAddress(
+ address2).build()).setDstMaskLength((short) mask2).build();
LispIpv4Address rloc = LispAddressUtil.asIPAfiAddress("20.0.0.2");
// Insert mapping in the database
etlr.getLocatorRecord().add(record.build());
mapRegister.setMappingRecordItem(new ArrayList<MappingRecordItem>());
mapRegister.getMappingRecordItem().add(new MappingRecordItemBuilder().setMappingRecord(etlr.build()).build());
- lms.handleMapRegister(mapRegister.build(), false);
+ lms.handleMapRegister(mapRegister.build());
// Get mapping using NB interface. No IID used
URL url = createGetMappingSourceDestURL(address1.getIpv4Address().getAfi(),
JSONObject json = new JSONObject(jt);
// With just one locator, locators is not a JSONArray
- String rlocRetrieved = json.getJSONArray("locators").getJSONObject(0).getJSONObject("locatorGeneric").getString("ipAddress");
+ String rlocRetrieved = json.getJSONArray("locators").getJSONObject(0).getJSONObject("locatorGeneric")
+ .getString("ipAddress");
assertEquals(rloc.getIpv4Address().getValue(), rlocRetrieved);
}
private URL createGetKeyIPv4URL(LispIpv4Address address, int mask) throws MalformedURLException {
- String restUrl = String.format("http://localhost:8080/lispflowmapping/nb/v2/default/%s/0/%d/%s/%d", "key", address.getAfi().shortValue(),
+ String restUrl = String.format("http://localhost:8080/lispflowmapping/nb/v2/default/%s/0/%d/%s/%d", "key",
+ address.getAfi().shortValue(),
address.getIpv4Address().getValue(), mask);
URL url = new URL(restUrl);
return url;
}
- private URL createGetKeySourceDestURL(int afi, String srcAddress, int srcMask, String dstAddress, int dstMask) throws MalformedURLException {
- String restUrl = String.format("http://localhost:8080/lispflowmapping/nb/v2/default/%s/0/%d/%s/%d/%s/%d", "key", afi, srcAddress, srcMask,
+ private URL createGetKeySourceDestURL(int afi, String srcAddress, int srcMask, String dstAddress, int dstMask)
+ throws MalformedURLException {
+ String restUrl = String.format("http://localhost:8080/lispflowmapping/nb/v2/default/%s/0/%d/%s/%d/%s/%d",
+ "key", afi, srcAddress, srcMask,
dstAddress, dstMask);
URL url = new URL(restUrl);
return url;
}
- private URL createGetMappingSourceDestURL(int afi, String srcAddress, int srcMask, String dstAddress, int dstMask) throws MalformedURLException {
- String restUrl = String.format("http://localhost:8080/lispflowmapping/nb/v2/default/%s/0/%d/%s/%d/%s/%d", "mapping", afi, srcAddress,
+ private URL createGetMappingSourceDestURL(int afi, String srcAddress, int srcMask, String dstAddress, int dstMask)
+ throws MalformedURLException {
+ String restUrl = String.format("http://localhost:8080/lispflowmapping/nb/v2/default/%s/0/%d/%s/%d/%s/%d",
+ "mapping", afi, srcAddress,
srcMask, dstAddress, dstMask);
URL url = new URL(restUrl);
return url;
}
private URL createGetMappingIPv4URL(int iid, LispIpv4Address address, int mask) throws MalformedURLException {
- String restUrl = String.format("http://localhost:8080/lispflowmapping/nb/v2/default/%s/%d/%d/%s/%d", "mapping", iid, address.getAfi()
+ String restUrl = String.format("http://localhost:8080/lispflowmapping/nb/v2/default/%s/%d/%d/%s/%d", "mapping",
+ iid, address.getAfi()
.shortValue(), address.getIpv4Address().getValue(), mask);
URL url = new URL(restUrl);
return url;
}
private URL createDeleteMappingIPv4URL(int iid, LispIpv4Address address, int mask) throws MalformedURLException {
- String restUrl = String.format("http://localhost:8080/lispflowmapping/nb/v2/default/%s/%d/%d/%s/%d", "mapping", iid, address.getAfi()
+ String restUrl = String.format("http://localhost:8080/lispflowmapping/nb/v2/default/%s/%d/%d/%s/%d", "mapping",
+ iid, address.getAfi()
.shortValue(), address.getIpv4Address().getValue(), mask);
URL url = new URL(restUrl);
return url;
return authStringEnc;
}
- private String callURL(String method, String content, String accept, String body, URL url) throws IOException, JSONException {
+ private String callURL(String method, String content, String accept, String body, URL url) throws IOException,
+ JSONException {
String authStringEnc = createAuthenticationString();
connection = (HttpURLConnection) url.openConnection();
connection.setRequestMethod(method);
public void eidPrefixLookupIPv4() throws SocketTimeoutException {
cleanUP();
- runPrefixTest(LispAddressUtil.asIpv4PrefixEid("1.2.3.4/16"), LispAddressUtil.asIpv4PrefixEid("1.2.3.2/32"),
- LispAddressUtil.asIpv4PrefixEid("1.1.1.1/32"));
+ runPrefixTest(LispAddressUtil.asIpv4PrefixBinaryEid("1.2.3.4/16"),
+ LispAddressUtil.asIpv4PrefixBinaryEid("1.2.3.2/32"),
+ LispAddressUtil.asIpv4PrefixBinaryEid("1.1.1.1/32"));
}
public void eidPrefixLookupIPv6() throws SocketTimeoutException {
cleanUP();
- 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"));
+ runPrefixTest(LispAddressUtil.asIpv6PrefixBinaryEid("1:2:3:4:5:6:7:8/64"),
+ LispAddressUtil.asIpv6PrefixBinaryEid("1:2:3:4:5:1:2:3/128"),
+ LispAddressUtil.asIpv6PrefixBinaryEid("1:2:3:1:2:3:1:2/128"));
}
private void runPrefixTest(Eid registerEID, Eid matchedAddress, Eid unMatchedAddress)
throws SocketTimeoutException {
+ mapService.addAuthenticationKey(registerEID, NULL_AUTH_KEY);
+ sleepForSeconds(1);
MapRegisterBuilder mapRegister = new MapRegisterBuilder();
mapRegister.setWantMapNotify(true);
sendMapRequest(mapRequest.build());
MapReply mapReply = receiveMapReply();
assertEquals(4, mapReply.getNonce().longValue());
- assertEquals(record.getRloc(), mapReply.getMappingRecordItem().get(0).getMappingRecord().getLocatorRecord().get(0).getRloc());
+ 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());
LOG.trace("Sending this JSON to LISP server: \n" + jsonAuthData);
LOG.trace("Address: " + address);
- byte[] expectedSha = new byte[] { (byte) 146, (byte) 234, (byte) 52, (byte) 247, (byte) 186, (byte) 232, (byte) 31, (byte) 249, (byte) 87,
- (byte) 73, (byte) 234, (byte) 54, (byte) 225, (byte) 160, (byte) 129, (byte) 251, (byte) 73, (byte) 53, (byte) 196, (byte) 62 };
+ byte[] expectedSha = new byte[] { (byte) 146, (byte) 234, (byte) 52, (byte) 247, (byte) 186, (byte) 232,
+ (byte) 31, (byte) 249, (byte) 87,
+ (byte) 73, (byte) 234, (byte) 54, (byte) 225, (byte) 160, (byte) 129, (byte) 251, (byte) 73, (byte) 53,
+ (byte) 196, (byte) 62 };
byte[] zeros = new byte[20];
sendMapRegister(mapRegister.build());
- assertMapNotifyRecieved();
+ assertMapNotifyReceived();
}
public void testPasswordMaskMatch() throws Exception {
mapRegister.setKeyId((short) 1); // LispKeyIDEnum.SHA1.getKeyID()
mapRegister
- .setAuthenticationData(new byte[] { -15, -52, 38, -94, 125, -111, -68, -79, 68, 6, 101, 45, -1, 47, -4, -67, -113, 104, -110, -71 });
+ .setAuthenticationData(new byte[] { -15, -52, 38, -94, 125, -111, -68, -79, 68, 6, 101, 45, -1, 47, -4,
+ -67, -113, 104, -110, -71 });
sendMapRegister(mapRegister.build());
- assertMapNotifyRecieved();
+ assertMapNotifyReceived();
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 });
+ .setAuthenticationData(new byte[] { -54, 68, -58, -91, -23, 22, -88, -31, 113, 39, 115, 78, -68, -123,
+ -71, -14, -99, 67, -23, -73 });
sendMapRegister(mapRegister.build());
assertNoPacketReceived(3000);
*/
// takes an address, packs it in a MapRegister and sends it
private void registerAddress(Eid eid) throws SocketTimeoutException {
+ mapService.addAuthenticationKey(eid, NULL_AUTH_KEY);
+ sleepForSeconds(1);
MapRegisterBuilder mapRegisterBuilder = new MapRegisterBuilder();
mapRegisterBuilder.setWantMapNotify(true);
mapRegisterBuilder.setKeyId((short) 0);
etlrBuilder.setLocatorRecord(new ArrayList<LocatorRecord>());
etlrBuilder.getLocatorRecord().add(recordBuilder.build());
mapRegisterBuilder.setMappingRecordItem(new ArrayList<MappingRecordItem>());
- mapRegisterBuilder.getMappingRecordItem().add(new MappingRecordItemBuilder().setMappingRecord(etlrBuilder.build()).build());
+ mapRegisterBuilder.getMappingRecordItem().add(
+ new MappingRecordItemBuilder().setMappingRecord(etlrBuilder.build()).build());
sendMapRegister(mapRegisterBuilder.build());
MapNotify mapNotify = receiveMapNotify();
assertEquals(8, mapNotify.getNonce().longValue());
if (srcEid != null) {
mapRequestBuilder.setSourceEid(new SourceEidBuilder().setEid(LispAddressUtil.asIpv4Eid(srcEid)).build());
} else {
- mapRequestBuilder.setSourceEid(new SourceEidBuilder().setEid(LispAddressUtil.asIpv4Eid(ourAddress)).build());
+ mapRequestBuilder.setSourceEid(new SourceEidBuilder().setEid(LispAddressUtil.asIpv4Eid(ourAddress))
+ .build());
}
mapRequestBuilder.getItrRloc().add(
new ItrRlocBuilder().setRloc(LispAddressUtil.asIpv4Rloc(ourAddress)).build());
// takes an address, packs it in a MapRegister, sends it, returns the
// MapReply
private MapReply registerAddressAndQuery(Eid eid) throws SocketTimeoutException {
+ mapService.addAuthenticationKey(eid, NULL_AUTH_KEY);
+ sleepForSeconds(1);
MapRegisterBuilder mapRegisterBuilder = new MapRegisterBuilder();
mapRegisterBuilder.setWantMapNotify(true);
mapRegisterBuilder.setKeyId((short) 0);
etlrBuilder.setLocatorRecord(new ArrayList<LocatorRecord>());
etlrBuilder.getLocatorRecord().add(recordBuilder.build());
mapRegisterBuilder.setMappingRecordItem(new ArrayList<MappingRecordItem>());
- mapRegisterBuilder.getMappingRecordItem().add(new MappingRecordItemBuilder().setMappingRecord(etlrBuilder.build()).build());
+ mapRegisterBuilder.getMappingRecordItem().add(new MappingRecordItemBuilder().setMappingRecord(
+ etlrBuilder.build()).build());
sendMapRegister(mapRegisterBuilder.build());
MapNotify mapNotify = receiveMapNotify();
assertEquals(8, mapNotify.getNonce().longValue());
// ------------------------------- LCAF Tests ---------------------------
- @Test
public void registerAndQuery__SrcDestLCAF() throws SocketTimeoutException {
cleanUP();
String ipPrefix = "10.20.30.200/32";
String macString = "01:02:03:04:05:06";
SourceDestKeyBuilder builder = new SourceDestKeyBuilder();
- builder.setSource(new SimpleAddress(new IpPrefix(new org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev100924.Ipv4Prefix(ipPrefix))));
+ builder.setSource(new SimpleAddress(new IpPrefix(new org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang
+ .ietf.inet.types.rev130715.Ipv4Prefix(ipPrefix))));
builder.setDest(new SimpleAddress(new MacAddress(macString)));
EidBuilder eb = new EidBuilder();
eb.setAddressType(SourceDestKeyLcaf.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.SourceDestKeyBuilder()
- .setSourceDestKey(builder.build()).build());
+ eb.setAddress(new org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.lisp.address.types.rev151105
+ .lisp.address.address.SourceDestKeyBuilder().setSourceDestKey(builder.build()).build());
MapReply reply = registerAddressAndQuery(eb.build());
assertEquals(macString, receivedMAC.getValue());
}
- @Test
public void registerAndQuery__SrcDestLCAFOverlap() throws SocketTimeoutException {
cleanUP();
String ipString1 = "10.10.10.0";
String ipPrefix2 = ipString2 + "/24";
Eid srcDst = LispAddressUtil.asSrcDstEid(ipString1, ipString2, 24, 24, 0);
- registerAddress(LispAddressUtil.asIpv4PrefixEid(ipPrefix2));
+ registerAddress(LispAddressUtil.asIpv4PrefixBinaryEid(ipPrefix2));
registerAddress(srcDst);
// exact match
assertEquals(ipPrefix2, receivedAddr2.getIpv4Prefix().getValue());
// srcEid/dstEid match
- reply = queryForAddress(LispAddressUtil.asIpv4PrefixEid("20.20.20.1/32"), "10.10.10.1");
+ reply = queryForAddress(LispAddressUtil.asIpv4PrefixBinaryEid("20.20.20.1/32"), "10.10.10.1");
fromNetwork = reply.getMappingRecordItem().get(0).getMappingRecord().getEid();
- assertEquals(Ipv4PrefixAfi.class, fromNetwork.getAddressType());
+ assertEquals(Ipv4PrefixBinaryAfi.class, fromNetwork.getAddressType());
- Ipv4Prefix ipAddr2 = (Ipv4Prefix) fromNetwork.getAddress();
- assertEquals(ipPrefix2, ipAddr2.getIpv4Prefix().getValue());
+ assertEquals(LispAddressUtil.asIpv4PrefixBinaryEid(ipPrefix2), fromNetwork);
// dstEid match only
- reply = queryForAddress(LispAddressUtil.asIpv4PrefixEid("20.20.20.1/32"), "1.2.3.4");
+ reply = queryForAddress(LispAddressUtil.asIpv4PrefixBinaryEid("20.20.20.1/32"), "1.2.3.4");
fromNetwork = reply.getMappingRecordItem().get(0).getMappingRecord().getEid();
- assertEquals(Ipv4PrefixAfi.class, fromNetwork.getAddressType());
+ assertEquals(Ipv4PrefixBinaryAfi.class, fromNetwork.getAddressType());
- ipAddr2 = (Ipv4Prefix) fromNetwork.getAddress();
- assertEquals(ipPrefix2, ipAddr2.getIpv4Prefix().getValue());
+ assertEquals(LispAddressUtil.asIpv4PrefixBinaryEid(ipPrefix2), fromNetwork);
}
- @Test
public void registerAndQuery__KeyValueLCAF() throws SocketTimeoutException {
cleanUP();
String ipString = "10.20.30.200";
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());
+ 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());
MapReply reply = registerAddressAndQuery(eb.build());
assertEquals(AfiListLcaf.class, receivedAddress.getAddressType());
AfiList listAddrFromNetwork = (AfiList) receivedAddress.getAddress();
- SimpleAddress receivedAddr1 = listAddrFromNetwork.getAfiList().getAddressList().get(0);
- SimpleAddress receivedAddr2 = listAddrFromNetwork.getAfiList().getAddressList().get(1);
+ SimpleAddress receivedAddr1 = (SimpleAddress) listAddrFromNetwork.getAfiList().getAddressList().get(0);
+ SimpleAddress receivedAddr2 = (SimpleAddress) listAddrFromNetwork.getAfiList().getAddressList().get(1);
assertNotNull(receivedAddr1.getIpAddress().getIpv4Address());
assertNotNull(receivedAddr2.getMacAddress());
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());
+ eb.setAddress(new Ipv4PrefixBuilder().setIpv4Prefix(new org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns
+ .yang.ietf.inet.types.rev130715.Ipv4Prefix(ipString)).build());
MapReply reply = registerAddressAndQuery(eb.build());
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());
+ 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());
+ assertEquals(ExplicitLocatorPathLcaf.class, reply.getMappingRecordItem().get(0).getMappingRecord().getEid()
+ .getAddressType());
- ExplicitLocatorPath receivedAddress = (ExplicitLocatorPath) reply.getMappingRecordItem().get(0).getMappingRecord().getEid().getAddress();
+ ExplicitLocatorPath receivedAddress = (ExplicitLocatorPath) reply.getMappingRecordItem().get(0)
+ .getMappingRecord().getEid().getAddress();
- Hop receivedHop1 = receivedAddress.getExplicitLocatorPath().getHop().get(0);
- Hop receivedHop2 = receivedAddress.getExplicitLocatorPath().getHop().get(1);
+ Hop receivedHop1 = (Hop) receivedAddress.getExplicitLocatorPath().getHop().get(0);
+ Hop receivedHop2 = (Hop) receivedAddress.getExplicitLocatorPath().getHop().get(1);
assertEquals(true, receivedHop1.getLrsBits().isLookup());
assertEquals(false, receivedHop1.getLrsBits().isRlocProbe());
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());
+ 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);
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());
+ 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());
SimpleAddress ipAddressReceived = receivedApplicationDataAddress.getApplicationData().getAddress();
assertEquals(ipString, ipAddressReceived.getIpAddress().getIpv4Address().getValue());
public void mapRequestMapRegisterAndMapRequestTestTimeout() throws SocketTimeoutException {
cleanUP();
- Eid eid = LispAddressUtil.asIpv4PrefixEid("1.2.3.4/32");
+ ConfigIni.getInstance().setSmrRetryCount(0);
+ Eid eid = LispAddressUtil.asIpv4PrefixBinaryEid("1.2.3.4/32");
+ mapService.addAuthenticationKey(eid, NULL_AUTH_KEY);
+ sleepForSeconds(1);
MapRequestBuilder mapRequestBuilder = new MapRequestBuilder();
mapRequestBuilder.setNonce((long) 4);
mapRequestBuilder.setSourceEid(new SourceEidBuilder().setEid(LispAddressUtil.getNoAddressEid()).build());
MappingRecordBuilder etlrBuilder = new MappingRecordBuilder();
etlrBuilder.setEid(eid);
- etlrBuilder.setMaskLength((short) 32);
etlrBuilder.setRecordTtl(254);
LocatorRecordBuilder recordBuilder = new LocatorRecordBuilder();
public void mapRequestMapRegisterAndMapRequestTestNativelyForwardTimeoutResponse() throws Exception {
cleanUP();
- Eid eid = LispAddressUtil.asIpv6PrefixEid("1.2.3.4/32");
+ Eid eid = LispAddressUtil.asIpv4PrefixBinaryEid("1.2.3.4/32");
MapRequest mapRequest = createMapRequest(eid);
testTTLBeforeRegister(mapRequest);
}
+ private void timedOutMappingRecord() {
+ cleanUP();
+ mapService.setMappingMerge(true);
+ // mapping expires after 1 second
+ ConfigIni.getInstance().setRegistrationValiditySb(1000L);
+
+ final Eid eid = LispAddressUtil.asIpv4PrefixBinaryEid("1.2.3.4/32", new InstanceIdType(10L));
+ final XtrId xtrId = new XtrId(new byte[]{1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16});
+ final SiteId siteId = new SiteId(new byte[]{1, 2, 3, 4, 5, 6, 7, 8});
+
+ final LocatorRecord locatorRecord = new LocatorRecordBuilder()
+ .setRloc(LispAddressUtil.asIpv4Rloc("1.1.1.1")).setLocatorId("locator-id").build();
+ final MappingRecord mappingRecord = new MappingRecordBuilder()
+ .setEid(eid)
+ .setSiteId(siteId)
+ .setRecordTtl(1000)
+ .setXtrId(xtrId)
+ .setAction(Action.NoAction)
+ .setAuthoritative(true)
+ .setLocatorRecord(Lists.newArrayList()).build();
+ mappingRecord.getLocatorRecord().add(locatorRecord);
+
+ mapService.addAuthenticationKey(eid, NULL_AUTH_KEY);
+ mapService.addMapping(MappingOrigin.Southbound, eid, siteId,
+ new MappingData(mappingRecord, System.currentTimeMillis()));
+ sleepForSeconds(2);
+
+ MappingRecord resultRecord = (MappingRecord) mapService.getMapping(MappingOrigin.Southbound, eid);
+ assertNull(resultRecord);
+ }
+
private void testTTLAfterClean(MapRequest mapRequest) throws SocketTimeoutException {
MapReply mapReply;
sendMapRequest(mapRequest);
private void registerForTTL(Eid eid) throws SocketTimeoutException {
MapRegister mapRegister = createMapRegister(eid);
sendMapRegister(mapRegister);
- assertMapNotifyRecieved();
+ assertMapNotifyReceived();
}
private void testTTLBeforeRegister(MapRequest mapRequest) throws SocketTimeoutException {
mapRegisterbuilder.setKeyId((short) 0);
MappingRecordBuilder etlrBuilder = new MappingRecordBuilder();
etlrBuilder.setEid(eid);
- etlrBuilder.setMaskLength((short) 24);
etlrBuilder.setRecordTtl(254);
etlrBuilder.setAuthoritative(false);
etlrBuilder.setAction(Action.NoAction);
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()
+ 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();
public void onXtrRequestMapping(XtrRequestMapping notification) {
}
+ @Override
+ public void onMappingKeepAlive(MappingKeepAlive notification) {
+ }
+
}
public void testRecievingNonProxyOnXtrPort() throws SocketTimeoutException, SocketException, Throwable {
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()
+ 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() {
+ ((LispMappingService) lms).getNotificationService().registerNotificationListener(
+ new XtrRequestMappingListener() {
@Override
public void onXtrRequestMapping(XtrRequestMapping notification) {
}
- private void sendProxyMapRequest(String rloc, int port, Rloc adLcaf) throws SocketTimeoutException, SocketException {
+ 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));
- MapRequest recievedMapRequest = receiveMapRequest(nonProxySocket);
- assertEquals(mapRequest.getNonce(), recievedMapRequest.getNonce());
- assertEquals(mapRequest.getSourceEid(), recievedMapRequest.getSourceEid());
- assertEquals(mapRequest.getItrRloc(), recievedMapRequest.getItrRloc());
- assertEquals(mapRequest.getEidItem(), recievedMapRequest.getEidItem());
+ MapRequest receivedMapRequest = receiveMapRequest(nonProxySocket);
+ assertEquals(mapRequest.getNonce(), receivedMapRequest.getNonce());
+ assertEquals(mapRequest.getSourceEid(), receivedMapRequest.getSourceEid());
+ assertEquals(mapRequest.getItrRloc(), receivedMapRequest.getItrRloc());
+ assertEquals(mapRequest.getEidItem(), receivedMapRequest.getEidItem());
nonProxySocket.close();
}
private MapRequest createNonProxyMapRequest(String eid, Rloc adLcaf) throws SocketTimeoutException {
- MapRegister mr = createMapRegister(LispAddressUtil.asIpv4PrefixEid(eid));
+ MapRegister mr = createMapRegister(LispAddressUtil.asIpv4PrefixBinaryEid(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(LispAddressUtil.asIpv4PrefixEid(eid));
+ assertMapNotifyReceived();
+ MapRequest mapRequest = createMapRequest(LispAddressUtil.asIpv4PrefixBinaryEid(eid));
MapRequestBuilder builder = new MapRequestBuilder(mapRequest);
builder.setPitr(true);
mapRequest = builder.build();
return mapRequest;
}
- private void assertMapNotifyRecieved() throws SocketTimeoutException {
+ private void assertMapNotifyReceived() throws SocketTimeoutException {
receiveMapNotify();
}
private MapReply receiveMapReply() throws SocketTimeoutException {
- return MapReplySerializer.getInstance().deserialize(ByteBuffer.wrap(receivePacket().getData()));
+ return receiveMapReply(socket, 1000);
}
private MapRequest receiveMapRequest(DatagramSocket datagramSocket) throws SocketTimeoutException {
- return MapRequestSerializer.getInstance().deserialize(ByteBuffer.wrap(receivePacket(datagramSocket, 30000).getData()));
+ return MapRequestSerializer.getInstance().deserialize(ByteBuffer.wrap(receivePacket(
+ datagramSocket, 30000).getData()), null);
}
private MapNotify receiveMapNotify() throws SocketTimeoutException {
LOG.trace("Waiting for packet from socket...");
receivedSocket.setSoTimeout(timeout);
receivedSocket.receive(receivePacket);
- LOG.trace("Recieved packet from socket!");
+ LOG.trace("Received packet from socket!");
return receivePacket;
} catch (SocketTimeoutException ste) {
throw ste;
}
}
+ private MapReply receiveMapReply(DatagramSocket receivedSocket, int timeout) throws SocketTimeoutException {
+ DatagramPacket packet;
+ try {
+ while (true) {
+ packet = receivePacket(receivedSocket, timeout);
+ final ByteBuffer buff = ByteBuffer.wrap(packet.getData());
+ final int type = ByteUtil.getUnsignedByte(buff, LispMessage.Pos.TYPE) >> 4;
+ final Object lispType = MessageType.forValue(type);
+
+ if (lispType == MessageType.MapReply) {
+ return MapReplySerializer.getInstance().deserialize(buff);
+ }
+ }
+ } catch (SocketTimeoutException ste) {
+ throw ste;
+ }
+ }
private void sleepForSeconds(int seconds) {
try {
Thread.sleep(seconds*1000);
} catch (InterruptedException e) {
- LOG.warn("Interrupted while sleeping");
- e.printStackTrace();
+ LOG.warn("Interrupted while sleeping", e);
+ }
+ }
+
+ private void sleepForMilliseconds(long milliseconds) {
+ try {
+ Thread.sleep(milliseconds);
+ } catch (InterruptedException e) {
+ LOG.warn("Interrupted while sleeping", e);
}
}
}
private DatagramSocket initSocket(DatagramSocket socket, int port) {
- try {
- socket = new DatagramSocket(new InetSocketAddress(ourAddress, port));
- } catch (SocketException e) {
- e.printStackTrace();
- fail();
+ for (int i=0; i < NUM_OF_ATTEMPTS_TO_CREATE_SOCKET; i++) {
+ try {
+ return new DatagramSocket(new InetSocketAddress(ourAddress, port));
+ } catch (SocketException e) {
+ LOG.error("Can't initialize socket for {}", ourAddress, e);
+ }
}
- return socket;
+ fail();
+ return null;
}
private byte[] extractWSUdpByteArray(String wiresharkHex) {
}
private void areWeReady() throws InvalidSyntaxException {
- try {
- Thread.sleep(5000);
- } catch (InterruptedException e) {
- }
+ sleepForSeconds(5);
assertNotNull(bc);
boolean debugit = false;
Bundle b[] = bc.getBundles();
for (Bundle element : b) {
int state = element.getState();
- LOG.trace("Bundle[" + element.getBundleId() + "]:" + element.getSymbolicName() + ",v" + element.getVersion() + ", state:"
- + stateToString(state));
+ LOG.trace("Bundle[" + element.getBundleId() + "]:" + element.getSymbolicName() + ",v"
+ + element.getVersion() + ", state:" + stateToString(state));
if (state != Bundle.ACTIVE && state != Bundle.RESOLVED) {
LOG.debug("Bundle:" + element.getSymbolicName() + " state:" + stateToString(state));
}
*/
- try {
- Thread.sleep(1000);
- } catch (InterruptedException e) {
- }
+ sleepForSeconds(1);
}
private void cleanUP() {
}
+ private void restartSocket() {
+ after();
+ socket = initSocket(socket, LispMessage.PORT_NUM);
+ }
+
}
Code Review / lispflowmapping.git / blobdiff