+/*
+ * Copyright (c) 2016, 2017 Cisco Systems, Inc. and others. All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v1.0 which accompanies this distribution,
+ * and is available at http://www.eclipse.org/legal/epl-v10.html
+ */
package org.opendaylight.lispflowmapping.implementation.lisp;
import static org.junit.Assert.assertEquals;
+import com.google.common.collect.Lists;
import java.util.ArrayList;
-import java.util.HashMap;
import java.util.List;
-import java.util.Map;
-
-import junit.framework.Assert;
-
-import org.jmock.api.Invocation;
+import java.util.Set;
import org.junit.Before;
import org.junit.Ignore;
import org.junit.Test;
+import org.mockito.ArgumentCaptor;
+import org.mockito.Mockito;
+import org.opendaylight.lispflowmapping.config.ConfigIni;
import org.opendaylight.lispflowmapping.implementation.LispMappingService;
-import org.opendaylight.lispflowmapping.interfaces.dao.ILispDAO;
-import org.opendaylight.lispflowmapping.interfaces.dao.IMappingServiceKey;
-import org.opendaylight.lispflowmapping.interfaces.dao.MappingServiceKeyUtil;
-import org.opendaylight.lispflowmapping.interfaces.dao.MappingServiceRLOC;
-import org.opendaylight.lispflowmapping.interfaces.dao.MappingServiceValue;
-import org.opendaylight.lispflowmapping.tools.junit.BaseTestCase;
-import org.opendaylight.lispflowmapping.type.lisp.EidRecord;
-import org.opendaylight.lispflowmapping.type.lisp.EidToLocatorRecord;
-import org.opendaylight.lispflowmapping.type.lisp.LocatorRecord;
-import org.opendaylight.lispflowmapping.type.lisp.MapReply;
-import org.opendaylight.lispflowmapping.type.lisp.MapReplyAction;
-import org.opendaylight.lispflowmapping.type.lisp.MapRequest;
-import org.opendaylight.lispflowmapping.type.lisp.address.LispAddress;
-import org.opendaylight.lispflowmapping.type.lisp.address.LispIpv4Address;
-import org.opendaylight.lispflowmapping.type.lisp.address.LispIpv6Address;
-
-/*
- * Copyright (c) 2013 Contextream, Inc. and others. All rights reserved.
- *
- * This program and the accompanying materials are made available under the
- * terms of the Eclipse Public License v1.0 which accompanies this distribution,
- * and is available at http://www.eclipse.org/legal/epl-v10.html
- */
+import org.opendaylight.lispflowmapping.implementation.MappingService;
+import org.opendaylight.lispflowmapping.interfaces.dao.SubKeys;
+import org.opendaylight.lispflowmapping.interfaces.dao.Subscriber;
+import org.opendaylight.lispflowmapping.lisp.type.LispMessage;
+import org.opendaylight.lispflowmapping.lisp.type.MappingData;
+import org.opendaylight.lispflowmapping.lisp.util.LispAddressUtil;
+import org.opendaylight.lispflowmapping.lisp.util.SourceDestKeyHelper;
+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.Ipv4Address;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.Ipv6Address;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.lisp.address.types.rev151105.Ipv4Afi;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.lisp.address.types.rev151105.Ipv6Afi;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.lisp.address.types.rev151105.LispAddressFamily;
+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.NoAddressAfi;
+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.Ipv4Builder;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.lisp.address.types.rev151105.lisp.address.address.Ipv6Builder;
+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.MacBuilder;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.lisp.address.types.rev151105.lisp.address.address.NoAddress;
+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.IpAddressBinary;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.inet.binary.types.rev160303.Ipv4AddressBinary;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.inet.binary.types.rev160303.Ipv6AddressBinary;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.binary.address.types.rev160504.Ipv4BinaryAfi;
+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.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.LocatorRecordBuilder;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.locatorrecords.LocatorRecordKey;
+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.MappingRecordBuilder;
+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.mapreplymessage.MapReplyBuilder;
+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.ItrRlocKey;
+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.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.opendaylight.lfm.mappingservice.rev150906.MappingOrigin;
+
+public class MapResolverTest {
+
+ private static MapResolver mapResolver;
+ private static MappingService mapServiceMock;
+ private static Set<Subscriber> subscriberSetMock;
+ private static LispMappingService lispMappingServiceMock;
+
+ private static final String ITR_RLOC_KEY_STRING = "itr_rloc_key";
+ private static final String ITR_RLOC_ID_STRING = "itr_rloc_id";
+ private static final String IPV4_STRING_1 = "1.2.3.0";
+ private static final String IPV4_STRING_2 = "1.2.4.0";
+ private static final String IPV4_RLOC_STRING_1 = "100.100.100.100";
+ private static final String IPV4_SOURCE = "127.0.0.1";
+ private static final String IPV4_PREFIX_STRING = "/24";
+ private static final String IPV6_STRING = "0:0:0:0:0:0:0:1";
+ private static final String IPV6_PREFIX_STRING = "/128";
+
+ private static final byte[] IPV4_BINARY_BYTES_1 = new byte[]{1, 2, 3, 0};
+ private static final byte[] IPV4_BINARY_BYTES_2 = new byte[]{1, 2, 5, 0};
+ private static final byte[] IPV6_BINARY_BYTES_1 = new byte[]{1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1};
+
+ private static final LocatorRecordKey LOCATOR_RECORD_KEY = new LocatorRecordKey("key");
+ private static final int TTL_RLOC_TIMED_OUT = 1;
+
+ private static final IpAddress IPV4_ADDRESS_1 = new IpAddress(new Ipv4Address(IPV4_STRING_1));
+ private static final IpAddress IPV4_ADDRESS_2 = new IpAddress(new Ipv4Address(IPV4_STRING_2));
+
+ private static final IpAddressBinary IPV4_ADDRESS_BINARY_1 =
+ new IpAddressBinary(new Ipv4AddressBinary(IPV4_BINARY_BYTES_1));
+ private static final IpAddressBinary IPV4_ADDRESS_BINARY_2 =
+ new IpAddressBinary(new Ipv4AddressBinary(IPV4_BINARY_BYTES_2));
+ private static final IpAddressBinary IPV6_ADDRESS_BINARY =
+ new IpAddressBinary(new Ipv6AddressBinary(IPV6_BINARY_BYTES_1));
+
+ private static final Eid IPV4_PREFIX_EID_1 = LispAddressUtil.asIpv4PrefixEid(IPV4_STRING_1 + IPV4_PREFIX_STRING);
+ private static final Eid IPV4_PREFIX_EID_2 = LispAddressUtil.asIpv4PrefixEid(IPV4_STRING_2 + IPV4_PREFIX_STRING);
+ private static final Eid IPV6_PREFIX_EID = LispAddressUtil.asIpv6PrefixEid(IPV6_STRING + IPV6_PREFIX_STRING);
+ private static final Eid SOURCE_DEST_KEY_EID = LispAddressUtil.asSrcDstEid(IPV4_SOURCE, IPV4_STRING_2, 24, 24, 0);
+
+ private static final Address IPV4_ADDRESS = new Ipv4Builder().setIpv4(new Ipv4Address(IPV4_STRING_1)).build();
+ private static final Address IPV6_ADDRESS = new Ipv6Builder().setIpv6(new Ipv6Address(IPV6_STRING)).build();
+
+ private static final Rloc RLOC_1 = LispAddressUtil.asIpv4Rloc(IPV4_RLOC_STRING_1);
+ private static MapRequestBuilder mapRequestBuilder = getDefaultMapRequestBuilder();
+ private static final Subscriber SUBSCRIBER_RLOC_1 = new Subscriber(RLOC_1,
+ LispAddressUtil.asIpv4Eid(IPV4_SOURCE), Subscriber.DEFAULT_SUBSCRIBER_TIMEOUT);
-public class MapResolverTest extends BaseTestCase {
-
- // private MapResolver testedMapResolver;
- private LispMappingService testedMapResolver;
-
- private ILispDAO lispDAO;
- private MapRequest mapRequest;
- private LispIpv4Address v4Address;
- private LispIpv6Address v6Address;
-
- private HashMap<IMappingServiceKey, Map<String, MappingServiceValue>> daoResults;
-
- @Override
@Before
- public void before() throws Exception {
- super.before();
- lispDAO = context.mock(ILispDAO.class);
- testedMapResolver = new LispMappingService();
- testedMapResolver.basicInit(lispDAO);
-
- mapRequest = new MapRequest();
- v4Address = new LispIpv4Address("1.2.3.4");
- v6Address = new LispIpv6Address("0:0:0:0:0:0:0:1");
- daoResults = new HashMap<IMappingServiceKey, Map<String, MappingServiceValue>>();
+ @SuppressWarnings("unchecked")
+ public void init() throws Exception {
+ mapServiceMock = Mockito.mock(MappingService.class, "mapService");
+ subscriberSetMock = Mockito.mock(Set.class);
+ lispMappingServiceMock = Mockito.mock(LispMappingService.class, "requestHandler");
+ mapResolver = new MapResolver(mapServiceMock, true, ConfigIni.getInstance().getElpPolicy(),
+ lispMappingServiceMock);
+ mapRequestBuilder = getDefaultMapRequestBuilder();
}
+ /**
+ * Tests {@link MapResolver#handleMapRequest} method.
+ */
@Test
- @Ignore
- public void handleMapRequest__NumRLOCsMismatch() throws Exception {
- mapRequest.addEidRecord(new EidRecord((byte) 0, v4Address));
- EidToLocatorRecord record = new EidToLocatorRecord().setPrefix(v4Address);
- record.addLocator(new LocatorRecord().setLocator(new LispIpv4Address(0x44332211)));
- // Map<String, Object> rlocs = prepareMapping(record);
- // rlocs.put("NumRLOCs", 5);
-
- MapReply mapReply = testedMapResolver.handleMapRequest(mapRequest);
-
- EidToLocatorRecord eidToLocators = mapReply.getEidToLocatorRecords().get(0);
- assertEquals(1, eidToLocators.getLocators().size());
- assertLocator(new LispIpv4Address(0x44332211), eidToLocators.getLocators().get(0));
+ public void handleMapRequest__withSingleLocator() {
+ // input mapping
+ final LocatorRecordBuilder locatorRecordBuilder = getDefaultLocatorBuilder();
+ final MappingRecordBuilder mappingRecordBuilder = getDefaultMappingRecordBuilder();
+ mappingRecordBuilder.getLocatorRecord().add(locatorRecordBuilder.build());
+ final MappingData mappingData = getDefaultMappingData(mappingRecordBuilder.build());
+
+ Mockito.when(mapServiceMock.getMapping(mapRequestBuilder.getSourceEid().getEid(), IPV4_PREFIX_EID_1))
+ .thenReturn(mappingData);
+
+ // result
+ final MapReplyBuilder mapReplyBuilder = getDefaultMapReplyBuilder();
+ mapReplyBuilder.getMappingRecordItem().add(new MappingRecordItemBuilder()
+ .setMappingRecord(mappingRecordBuilder.build()).build());
+
+ mapResolver.handleMapRequest(mapRequestBuilder.build());
+ Mockito.verify(lispMappingServiceMock).handleMapReply(mapReplyBuilder.build());
}
+ /**
+ * Tests {@link MapResolver#handleMapRequest} method.
+ */
@Test
- @Ignore
- public void handleMapRequest__BadRLOCType() throws Exception {
- mapRequest.addEidRecord(new EidRecord((byte) 0, v4Address));
- EidToLocatorRecord record = new EidToLocatorRecord().setPrefix(v4Address);
- record.addLocator(new LocatorRecord().setLocator(new LispIpv4Address(0x71717171)));
- record.addLocator(new LocatorRecord().setLocator(new LispIpv4Address(0x44332211)));
- // Map<String, Object> rlocs = prepareMapping(record);
- // rlocs.put("RLOC0", "Ooga booga");
-
- MapReply mapReply = testedMapResolver.handleMapRequest(mapRequest);
-
- EidToLocatorRecord eidToLocators = mapReply.getEidToLocatorRecords().get(0);
- assertEquals(1, eidToLocators.getLocators().size());
- assertLocator(new LispIpv4Address(0x44332211), eidToLocators.getLocators().get(0));
+ public void handleMapRequest__withNoMapping() {
+ final MappingRecordBuilder mappingRecordBuilder = new MappingRecordBuilder()
+ .setAuthoritative(false)
+ .setMapVersion((short) 0)
+ .setEid(IPV4_PREFIX_EID_1)
+ .setAction(LispMessage.NEGATIVE_MAPPING_ACTION)
+ .setRecordTtl(TTL_RLOC_TIMED_OUT);
+
+ Mockito.when(mapServiceMock.getMapping(mapRequestBuilder.getSourceEid().getEid(), IPV4_PREFIX_EID_1))
+ .thenReturn(null);
+ Mockito.when(mapServiceMock.addNegativeMapping(IPV4_PREFIX_EID_1))
+ .thenReturn(getDefaultMappingData(mappingRecordBuilder.build()));
+
+ // result
+ final MapReplyBuilder mapReplyBuilder = getDefaultMapReplyBuilder();
+ mapReplyBuilder.getMappingRecordItem().add(new MappingRecordItemBuilder()
+ .setMappingRecord(mappingRecordBuilder.build()).build());
+
+ mapResolver.handleMapRequest(mapRequestBuilder.build());
+ Mockito.verify(lispMappingServiceMock).handleMapReply(mapReplyBuilder.build());
}
+ /**
+ * Tests {@link MapResolver#handleMapRequest} method.
+ */
@Test
- @Ignore
- public void handleMapRequest__NoNumRLOCs() throws Exception {
- mapRequest.addEidRecord(new EidRecord((byte) 0, v4Address));
- allowing(lispDAO).get(wany(IMappingServiceKey.class));
- ret(new HashMap<String, Object>());
-
- MapReply mapReply = testedMapResolver.handleMapRequest(mapRequest);
-
- EidToLocatorRecord eidToLocators = mapReply.getEidToLocatorRecords().get(0);
- assertEquals(0, eidToLocators.getLocators().size());
+ public void handleMapRequest__withSubscribers() {
+ // input mapping
+ final LocatorRecordBuilder locatorRecordBuilder = getDefaultLocatorBuilder();
+ final MappingRecordBuilder mappingRecordBuilder = getDefaultMappingRecordBuilder();
+ mappingRecordBuilder.getLocatorRecord().add(locatorRecordBuilder.build());
+ final MappingData mappingData = getDefaultMappingData(mappingRecordBuilder.build());
+
+ Mockito.when(mapServiceMock.getMapping(mapRequestBuilder.getSourceEid().getEid(), IPV4_PREFIX_EID_1))
+ .thenReturn(mappingData);
+ Mockito.when(mapServiceMock.getData(MappingOrigin.Southbound, IPV4_PREFIX_EID_1, SubKeys.SUBSCRIBERS))
+ .thenReturn(subscriberSetMock);
+ Mockito.when(subscriberSetMock.contains(Mockito.any(Subscriber.class))).thenReturn(false);
+
+ // result
+ final MapReplyBuilder mapReplyBuilder = getDefaultMapReplyBuilder();
+ mapReplyBuilder.getMappingRecordItem().add(new MappingRecordItemBuilder()
+ .setMappingRecord(mappingRecordBuilder.build()).build());
+
+ mapResolver.handleMapRequest(mapRequestBuilder.build());
+ Mockito.verify(lispMappingServiceMock).handleMapReply(mapReplyBuilder.build());
+ Mockito.verify(subscriberSetMock, Mockito.never()).remove(Mockito.any(Subscriber.class));
}
+ /**
+ * Tests {@link MapResolver#isEqualIpVersion} method.
+ */
@Test
@Ignore
- public void handleMapRequest__IllegalNumRLOCs() throws Exception {
- mapRequest.addEidRecord(new EidRecord((byte) 0, v4Address));
- EidToLocatorRecord record = new EidToLocatorRecord().setPrefix(v4Address);
- record.addLocator(new LocatorRecord().setLocator(new LispIpv4Address(0x44332211)));
- // Map<String, Object> rlocs = prepareMapping(record);
- // rlocs.put("NumRLOCs", "Bla");
-
- MapReply mapReply = testedMapResolver.handleMapRequest(mapRequest);
-
- EidToLocatorRecord eidToLocators = mapReply.getEidToLocatorRecords().get(0);
- assertEquals(0, eidToLocators.getLocators().size());
+ public void isEqualIpVersionTest() {
+ // input mapping
+ final LocatorRecordBuilder locatorRecordBuilder = getDefaultLocatorBuilder();
+ final MappingRecordBuilder mappingRecordBuilder = getDefaultMappingRecordBuilder();
+ mappingRecordBuilder.getLocatorRecord().add(locatorRecordBuilder.build());
+ final MappingData mappingData = getDefaultMappingData(mappingRecordBuilder.build());
+
+ Mockito.when(mapServiceMock.getMapping(mapRequestBuilder.getSourceEid().getEid(), IPV4_PREFIX_EID_1))
+ .thenReturn(mappingData);
+ Mockito.when(mapServiceMock.getData(MappingOrigin.Southbound, IPV4_PREFIX_EID_1, SubKeys.SUBSCRIBERS))
+ .thenReturn(subscriberSetMock);
+ Mockito.when(subscriberSetMock.contains(Mockito.any(Subscriber.class))).thenReturn(false);
+
+ // ----------------------
+ // with sourceRloc = null
+ List<ItrRloc> itrRlocList = Lists.newArrayList(
+ newItrRloc(MacAfi.class, null),
+ newItrRloc(Ipv4BinaryAfi.class, IPV4_ADDRESS));
+
+ ArgumentCaptor<Subscriber> captor = ArgumentCaptor.forClass(Subscriber.class);
+ mapResolver.handleMapRequest(mapRequestBuilder.setSourceRloc(null).setItrRloc(itrRlocList).build());
+ Mockito.verify(subscriberSetMock).add(captor.capture());
+ // Since mapRequest's sourceRloc is null, first ItrRloc from the itrRlocList must be used.
+ assertEquals(MacAfi.class, captor.getValue().getSrcRloc().getAddressType());
+
+ // ----------------------
+ // with sourceRloc address = itrRloc address
+ itrRlocList = Lists.newArrayList(
+ newItrRloc(MacAfi.class, null),
+ newItrRloc(Ipv4BinaryAfi.class, IPV4_ADDRESS));
+
+ MapRequest mapRequest = mapRequestBuilder
+ .setSourceRloc(IPV4_ADDRESS_BINARY_1)
+ .setItrRloc(itrRlocList).build();
+
+ captor = ArgumentCaptor.forClass(Subscriber.class);
+ mapResolver.handleMapRequest(mapRequest);
+ Mockito.verify(subscriberSetMock, Mockito.times(2)).add(captor.capture());
+ assertEquals(IPV4_ADDRESS, captor.getValue().getSrcRloc().getAddress());
+
+ // ----------------------
+ // with sourceRloc address Afi = itrRloc address Afi (for Ipv4)
+ itrRlocList = Lists.newArrayList(
+ newItrRloc(MacAfi.class, null),
+ newItrRloc(Ipv6Afi.class, IPV6_ADDRESS),
+ newItrRloc(Ipv4Afi.class, IPV4_ADDRESS));
+
+ mapRequest = mapRequestBuilder
+ .setSourceRloc(IPV6_ADDRESS_BINARY)
+ .setItrRloc(itrRlocList).build();
+
+ captor = ArgumentCaptor.forClass(Subscriber.class);
+ mapResolver.handleMapRequest(mapRequest);
+ Mockito.verify(subscriberSetMock, Mockito.times(3)).add(captor.capture());
+ assertEquals(IPV6_ADDRESS, captor.getValue().getSrcRloc().getAddress());
+
+ // ----------------------
+ // with sourceRloc address Afi = itrRloc address Afi (for Ipv6)
+ itrRlocList = Lists.newArrayList(
+ newItrRloc(MacAfi.class, null),
+ newItrRloc(Ipv6Afi.class, IPV6_ADDRESS),
+ newItrRloc(Ipv4Afi.class, IPV4_ADDRESS));
+
+ mapRequest = mapRequestBuilder
+ .setSourceRloc(IPV4_ADDRESS_BINARY_2)
+ .setItrRloc(itrRlocList).build();
+
+ captor = ArgumentCaptor.forClass(Subscriber.class);
+ mapResolver.handleMapRequest(mapRequest);
+ Mockito.verify(subscriberSetMock, Mockito.times(4)).add(captor.capture());
+ assertEquals(IPV4_ADDRESS, captor.getValue().getSrcRloc().getAddress());
+
+ // ----------------------
+ // with no common ip address nor Afi
+ final Mac mac = new MacBuilder().setMac(new MacAddress("aa:bb:cc:dd:ee:ff")).build();
+ itrRlocList = Lists.newArrayList(
+ newItrRloc(MacAfi.class, mac),
+ newItrRloc(NoAddressAfi.class, Mockito.mock(NoAddress.class)));
+
+ mapRequest = mapRequestBuilder
+ .setSourceRloc(IPV4_ADDRESS_BINARY_1)
+ .setItrRloc(itrRlocList).build();
+
+ captor = ArgumentCaptor.forClass(Subscriber.class);
+ mapResolver.handleMapRequest(mapRequest);
+ Mockito.verify(subscriberSetMock, Mockito.times(5)).add(captor.capture());
+ assertEquals(mac, captor.getValue().getSrcRloc().getAddress());
}
+ /**
+ * Tests {@link MapResolver#handleMapRequest} method.
+ */
@Test
- public void handleMapRequest__ReplyWithSingleLocator() throws Exception {
- mapRequest.addEidRecord(new EidRecord((byte) 0, new LispIpv4Address("1.2.3.4")));
-
- EidToLocatorRecord record = new EidToLocatorRecord().setPrefix(v4Address);
- record.setRecordTtl(100);
- LocatorRecord locator = new LocatorRecord().setLocator(new LispIpv4Address(0x04030201));
- locator.setLocalLocator(false);
- locator.setRouted(true);
- locator.setMulticastPriority((byte) 5);
- locator.setMulticastWeight((byte) 17);
- locator.setPriority((byte) 16);
- record.addLocator(locator);
- prepareMapping(record);
-
- MapReply mapReply = testedMapResolver.handleMapRequest(mapRequest);
-
- EidToLocatorRecord eidToLocators = mapReply.getEidToLocatorRecords().get(0);
- assertEquals(1, eidToLocators.getLocators().size());
- LocatorRecord resultLocator = mapReply.getEidToLocatorRecords().get(0).getLocators().get(0);
- assertEquals(locator.isLocalLocator(), resultLocator.isLocalLocator());
- assertEquals(locator.isRouted(), resultLocator.isRouted());
- assertEquals(locator.getMulticastPriority(), resultLocator.getMulticastPriority());
- assertEquals(locator.getMulticastWeight(), resultLocator.getMulticastWeight());
- assertEquals(locator.getPriority(), resultLocator.getPriority());
-
- assertLocator(new LispIpv4Address(0x04030201), eidToLocators.getLocators().get(0));
+ @Ignore
+ public void handleMapRequest__withSubscribersToRemove() {
+ // input mapping
+ final LocatorRecordBuilder locatorRecordBuilder = getDefaultLocatorBuilder();
+ final MappingRecordBuilder mappingRecordBuilder = getDefaultMappingRecordBuilder();
+ mappingRecordBuilder.getLocatorRecord().add(locatorRecordBuilder.build());
+ MappingData mappingData = getDefaultMappingData(mappingRecordBuilder.build());
+
+ Mockito.when(mapServiceMock.getMapping(mapRequestBuilder.getSourceEid().getEid(), IPV4_PREFIX_EID_1))
+ .thenReturn(mappingData);
+ Mockito.when(mapServiceMock.getData(MappingOrigin.Southbound, IPV4_PREFIX_EID_1, SubKeys.SUBSCRIBERS))
+ .thenReturn(subscriberSetMock);
+ Subscriber subscriberMock = new Subscriber(
+ mapRequestBuilder.getItrRloc().get(0).getRloc(),
+ mapRequestBuilder.getSourceEid().getEid(), Subscriber.DEFAULT_SUBSCRIBER_TIMEOUT);
+ subscriberMock.setSubscriberTtlByRecordTtl(
+ mappingRecordBuilder.getRecordTtl());
+ Mockito.when(subscriberSetMock.contains(subscriberMock))
+ .thenReturn(true);
+
+ // result
+ final MapReplyBuilder mapReplyBuilder = getDefaultMapReplyBuilder();
+ mapReplyBuilder.getMappingRecordItem().add(new MappingRecordItemBuilder()
+ .setMappingRecord(mappingRecordBuilder.build()).build());
+
+ // check if a subscriber is re-instantiating when there already is one in the subscriber set
+ mapResolver.handleMapRequest(mapRequestBuilder.build());
+ Mockito.verify(subscriberSetMock).remove(subscriberMock);
+ Mockito.verify(subscriberSetMock).add(subscriberMock);
+ Mockito.verify(lispMappingServiceMock).handleMapReply(mapReplyBuilder.build());
+ Mockito.verify(mapServiceMock).addData(MappingOrigin.Southbound, IPV4_PREFIX_EID_1,
+ SubKeys.SUBSCRIBERS, subscriberSetMock);
+
+ // verify that itrRloc is subscribed to dst address
+ mappingRecordBuilder.setEid(SOURCE_DEST_KEY_EID);
+ mapRequestBuilder.getEidItem().add(new EidItemBuilder().setEid(IPV4_PREFIX_EID_2).build());
+ mappingData = getDefaultMappingData(mappingRecordBuilder.build());
+ Mockito.when(mapServiceMock.getMapping(mapRequestBuilder.getSourceEid().getEid(), IPV4_PREFIX_EID_2))
+ .thenReturn(mappingData);
+
+ mapResolver.handleMapRequest(mapRequestBuilder.build());
+ Mockito.verify(mapServiceMock).getData(MappingOrigin.Southbound,
+ SourceDestKeyHelper.getDstBinary(SOURCE_DEST_KEY_EID), SubKeys.SUBSCRIBERS);
}
+ /**
+ * Tests {@link MapResolver#handleMapRequest} method.
+ */
@Test
- public void handleMapRequest__VerifyBasicFields() throws Exception {
- mapRequest.addEidRecord(new EidRecord((byte) 0, v4Address));
-
- EidToLocatorRecord record = new EidToLocatorRecord().setPrefix(v4Address);
- record.setRecordTtl(100);
- record.setAction(MapReplyAction.NativelyForward);
- record.setAuthoritative(true);
- record.addLocator(new LocatorRecord().setLocator(new LispIpv4Address(0x04030201)));
- prepareMapping(record);
-
- MapReply mapReply = testedMapResolver.handleMapRequest(mapRequest);
-
- assertEquals(mapRequest.getNonce(), mapReply.getNonce());
- EidToLocatorRecord eidToLocators = mapReply.getEidToLocatorRecords().get(0);
- assertEquals((byte) 0, eidToLocators.getMaskLength());
- assertEquals(v4Address, eidToLocators.getPrefix());
- assertEquals(record.isAuthoritative(), eidToLocators.isAuthoritative());
- assertEquals(record.getAction(), eidToLocators.getAction());
- assertEquals(record.getRecordTtl(), eidToLocators.getRecordTtl());
+ public void handleMapRequest_withBothPolicy() {
+ mapResolver = new MapResolver(mapServiceMock, true, "both", lispMappingServiceMock);
+
+ final List<IpAddress> ipAddressList = new ArrayList<>();
+ // hop 1
+ ipAddressList.add(IPV4_ADDRESS_1);
+ // hop 2
+ ipAddressList.add(IPV4_ADDRESS_2);
+
+ final Rloc rloc = LispAddressUtil.asTeLcafRloc(ipAddressList);
+ final LocatorRecordBuilder locatorRecordBuilder_1 = getDefaultLocatorBuilder();
+ final LocatorRecordBuilder locatorRecordBuilder_2 = getDefaultLocatorBuilder().setRloc(rloc);
+
+ // input mapping
+ final MappingRecordBuilder mappingRecordBuilder = getDefaultMappingRecordBuilder();
+ mappingRecordBuilder.getLocatorRecord().add(locatorRecordBuilder_1.build());
+ mappingRecordBuilder.getLocatorRecord().add(locatorRecordBuilder_2.build());
+ final MappingData mappingData = getDefaultMappingData(mappingRecordBuilder.build());
+
+ final MapRequestBuilder mrb = getDefaultMapRequestBuilder();
+ mrb.getItrRloc().add(new ItrRlocBuilder().setRloc(LispAddressUtil.asIpv4Rloc(IPV4_STRING_1)).build());
+ mrb.getItrRloc().add(new ItrRlocBuilder().setRloc(LispAddressUtil.asIpv4Rloc(IPV4_STRING_2)).build());
+
+ Mockito.when(mapServiceMock.getMapping(mrb.getSourceEid().getEid(), IPV4_PREFIX_EID_1)).thenReturn(mappingData);
+
+ // result
+ final LocatorRecordBuilder locatorRecordBuilder_3 = getDefaultLocatorBuilder()
+ // priority increased by 1
+ .setRloc(LispAddressUtil.asIpv4Rloc(IPV4_STRING_2)).setPriority((short) 1);
+ final MappingRecordBuilder resultMappingRecordBuilder = getDefaultMappingRecordBuilder();
+
+ // as Ipv4
+ resultMappingRecordBuilder.getLocatorRecord().add(locatorRecordBuilder_1.build());
+ // as ELP
+ resultMappingRecordBuilder.getLocatorRecord().add(locatorRecordBuilder_2.build());
+ // added to the result
+ resultMappingRecordBuilder.getLocatorRecord().add(locatorRecordBuilder_3.build());
+
+ final MapReplyBuilder mapReplyBuilder = getDefaultMapReplyBuilder();
+ mapReplyBuilder.getMappingRecordItem().add(new MappingRecordItemBuilder()
+ .setMappingRecord(resultMappingRecordBuilder.build()).build());
+
+ // invocation
+ mapResolver.handleMapRequest(mrb.build());
+ Mockito.verify(lispMappingServiceMock).handleMapReply(mapReplyBuilder.build());
}
+ /**
+ * Tests {@link MapResolver#handleMapRequest} method.
+ */
@Test
- public void handleMapRequest__VerifyMask() throws Exception {
- EidRecord mapRequestRecord = new EidRecord((byte) 0, v4Address);
- mapRequestRecord.setMaskLength(32);
- mapRequest.addEidRecord(mapRequestRecord);
-
- EidToLocatorRecord record = new EidToLocatorRecord().setPrefix(new LispIpv4Address("1.2.3.0")).setMaskLength(24);
- record.addLocator(new LocatorRecord().setLocator(new LispIpv4Address(0x04030201)));
- prepareMapping(record);
-
- MapReply mapReply = testedMapResolver.handleMapRequest(mapRequest);
-
- assertEquals(mapRequest.getNonce(), mapReply.getNonce());
- EidToLocatorRecord eidToLocators = mapReply.getEidToLocatorRecords().get(0);
- assertEquals((byte) 32, eidToLocators.getMaskLength());
- assertEquals(v4Address, eidToLocators.getPrefix());
+ public void handleMapRequest_withReplacePolicy() {
+ mapResolver = new MapResolver(mapServiceMock, true, "replace", lispMappingServiceMock);
+
+ final List<IpAddress> ipAddressList = new ArrayList<>();
+ // hop 1
+ ipAddressList.add(IPV4_ADDRESS_1);
+ // hop 2
+ ipAddressList.add(IPV4_ADDRESS_2);
+
+ final Rloc rloc = LispAddressUtil.asTeLcafRloc(ipAddressList);
+ final LocatorRecordBuilder locatorRecordBuilder_1 = getDefaultLocatorBuilder();
+ final LocatorRecordBuilder locatorRecordBuilder_2 = getDefaultLocatorBuilder().setRloc(rloc);
+
+ // input mapping
+ final MappingRecordBuilder mappingRecordBuilder = getDefaultMappingRecordBuilder();
+ mappingRecordBuilder.getLocatorRecord().add(locatorRecordBuilder_1.build());
+ mappingRecordBuilder.getLocatorRecord().add(locatorRecordBuilder_2.build());
+ final MappingData mappingData = getDefaultMappingData(mappingRecordBuilder.build());
+
+ final MapRequestBuilder mrb = getDefaultMapRequestBuilder();
+ mrb.getItrRloc().add(new ItrRlocBuilder().setRloc(LispAddressUtil.asIpv4Rloc(IPV4_STRING_1)).build());
+ mrb.getItrRloc().add(new ItrRlocBuilder().setRloc(LispAddressUtil.asIpv4Rloc(IPV4_STRING_2)).build());
+
+ Mockito.when(mapServiceMock.getMapping(mrb.getSourceEid().getEid(), IPV4_PREFIX_EID_1)).thenReturn(mappingData);
+
+ // result
+ final LocatorRecordBuilder locatorRecordBuilder_3 = getDefaultLocatorBuilder()
+ .setRloc(LispAddressUtil.asIpv4Rloc(IPV4_STRING_2));
+ final MappingRecordBuilder resultMappingRecordBuilder = getDefaultMappingRecordBuilder();
+
+ // as Ipv4
+ resultMappingRecordBuilder.getLocatorRecord().add(locatorRecordBuilder_1.build());
+ // added to the result
+ resultMappingRecordBuilder.getLocatorRecord().add(locatorRecordBuilder_3.build());
+
+ final MapReplyBuilder mapReplyBuilder = getDefaultMapReplyBuilder();
+ mapReplyBuilder.getMappingRecordItem().add(new MappingRecordItemBuilder()
+ .setMappingRecord(resultMappingRecordBuilder.build()).build());
+
+ // invocation
+ mapResolver.handleMapRequest(mrb.build());
+ Mockito.verify(lispMappingServiceMock).handleMapReply(mapReplyBuilder.build());
}
+ /**
+ * Tests {@link MapResolver#handleMapRequest} method.
+ */
@Test
- public void handleMapRequest__VerifyMaskIPv6() throws Exception {
- EidRecord mapRequestRecord = new EidRecord((byte) 0, v6Address);
- mapRequestRecord.setMaskLength(128);
- mapRequest.addEidRecord(mapRequestRecord);
-
- EidToLocatorRecord record = new EidToLocatorRecord().setPrefix(new LispIpv6Address("0:0:0:0:0:0:0:0")).setMaskLength(128);
- record.addLocator(new LocatorRecord().setLocator(new LispIpv4Address(0x04030201)));
- prepareMapping(record);
-
- MapReply mapReply = testedMapResolver.handleMapRequest(mapRequest);
-
- assertEquals(mapRequest.getNonce(), mapReply.getNonce());
- EidToLocatorRecord eidToLocators = mapReply.getEidToLocatorRecords().get(0);
- assertEquals((byte) 128, eidToLocators.getMaskLength());
- assertEquals(v6Address, eidToLocators.getPrefix());
+ public void handleMapRequest_withMultipleEids() {
+ mapRequestBuilder.getEidItem().add(new EidItemBuilder().setEid(IPV6_PREFIX_EID).build());
+
+ final LocatorRecordBuilder locatorRecordBuilder_1 = getDefaultLocatorBuilder();
+ final LocatorRecordBuilder locatorRecordBuilder_2 = getDefaultLocatorBuilder();
+ locatorRecordBuilder_2.setRloc(LispAddressUtil.asIpv6Rloc(IPV6_STRING));
+
+ //input mapping
+ final MappingRecordBuilder mappingRecordBuilder_1 = getDefaultMappingRecordBuilder();
+ mappingRecordBuilder_1.getLocatorRecord().add(locatorRecordBuilder_1.build());
+ final MappingData mappingData_1 = getDefaultMappingData(mappingRecordBuilder_1.build());
+ final MappingRecordBuilder mappingRecordBuilder_2 = getDefaultMappingRecordBuilder();
+ mappingRecordBuilder_2.getLocatorRecord().add(locatorRecordBuilder_2.build());
+ mappingRecordBuilder_2.setEid(IPV6_PREFIX_EID);
+ final MappingData mappingData_2 = getDefaultMappingData(mappingRecordBuilder_2.build());
+
+ Mockito.when(mapServiceMock.getMapping(mapRequestBuilder.getSourceEid().getEid(),
+ mapRequestBuilder.getEidItem().get(0).getEid())).thenReturn(mappingData_1);
+ Mockito.when(mapServiceMock.getMapping(mapRequestBuilder.getSourceEid().getEid(),
+ mapRequestBuilder.getEidItem().get(1).getEid())).thenReturn(mappingData_2);
+
+ //result
+ final MapReplyBuilder mapReplyBuilder = getDefaultMapReplyBuilder();
+ mapReplyBuilder.getMappingRecordItem()
+ .add(new MappingRecordItemBuilder().setMappingRecord(mappingRecordBuilder_1.build()).build());
+ mapReplyBuilder.getMappingRecordItem()
+ .add(new MappingRecordItemBuilder().setMappingRecord(mappingRecordBuilder_2.build()).build());
+
+ mapResolver.handleMapRequest(mapRequestBuilder.build());
+ Mockito.verify(lispMappingServiceMock).handleMapReply(mapReplyBuilder.build());
}
- @Test
- public void handleMapRequest__VerifyMaskIPv6NoMatch() throws Exception {
- EidRecord mapRequestRecord = new EidRecord((byte) 128, v6Address);
- mapRequest.addEidRecord(mapRequestRecord);
-
- EidToLocatorRecord record = new EidToLocatorRecord().setPrefix(new LispIpv6Address("0:1:0:0:0:0:0:1")).setMaskLength(112);
- record.addLocator(new LocatorRecord().setLocator(new LispIpv4Address(0x04030201)));
- prepareMapping(record);
-
- MapReply mapReply = testedMapResolver.handleMapRequest(mapRequest);
-
- EidToLocatorRecord eidToLocators = mapReply.getEidToLocatorRecords().get(0);
- assertEquals(0, eidToLocators.getLocators().size());
+ private static ItrRloc newItrRloc(Class<? extends LispAddressFamily> clazz, Address address) {
+ return new ItrRlocBuilder().setRloc(new RlocBuilder()
+ .setAddress(address)
+ .setAddressType(clazz).build()).build();
}
- @Test
- public void handleMapRequest__VerifyMaskNoMatch() throws Exception {
- EidRecord mapRequestRecord = new EidRecord((byte) 0, v4Address);
- mapRequestRecord.setMaskLength(32);
- mapRequest.addEidRecord(mapRequestRecord);
-
- EidToLocatorRecord record = new EidToLocatorRecord().setPrefix(new LispIpv4Address("1.2.4.0")).setMaskLength(24);
- record.addLocator(new LocatorRecord().setLocator(new LispIpv4Address(0x04030201)));
- prepareMapping(record);
-
- MapReply mapReply = testedMapResolver.handleMapRequest(mapRequest);
-
- EidToLocatorRecord eidToLocators = mapReply.getEidToLocatorRecords().get(0);
- assertEquals(0, eidToLocators.getLocators().size());
+ private static List<ItrRloc> getDefaultItrRlocList() {
+ final List<ItrRloc> itrRlocList = new ArrayList<>();
+ final ItrRloc itrRloc = new ItrRlocBuilder()
+ .setKey(new ItrRlocKey(ITR_RLOC_KEY_STRING))
+ .setItrRlocId(ITR_RLOC_ID_STRING)
+ .setRloc(RLOC_1).build();
+ itrRlocList.add(itrRloc);
+ return itrRlocList;
}
- @Test
- public void handleMapRequest__ReplyWithMultipleLocators() throws Exception {
- mapRequest.addEidRecord(new EidRecord((byte) 0, v4Address));
-
- EidToLocatorRecord record = new EidToLocatorRecord().setPrefix(v4Address);
- record.setRecordTtl(100);
- record.addLocator(new LocatorRecord().setLocator(new LispIpv4Address(0x04030201)));
- record.addLocator(new LocatorRecord().setLocator(new LispIpv6Address("::1")));
- record.addLocator(new LocatorRecord().setLocator(new LispIpv4Address("1.8.2.7")));
- prepareMapping(record);
-
- MapReply mapReply = testedMapResolver.handleMapRequest(mapRequest);
-
- EidToLocatorRecord eidToLocators = mapReply.getEidToLocatorRecords().get(0);
- assertEquals(3, eidToLocators.getLocators().size());
-
- assertLocator(new LispIpv4Address(0x04030201), eidToLocators.getLocators().get(0));
- assertLocator(new LispIpv6Address("::1"), eidToLocators.getLocators().get(1));
- assertLocator(new LispIpv4Address("1.8.2.7"), eidToLocators.getLocators().get(2));
+ private static MapRequestBuilder getDefaultMapRequestBuilder() {
+ MapRequestBuilder mrBuilder = new MapRequestBuilder()
+ .setAuthoritative(false)
+ .setEidItem(new ArrayList<>())
+ .setItrRloc(new ArrayList<>())
+ .setMapDataPresent(true)
+ .setNonce((long) 0)
+ .setPitr(false)
+ .setProbe(false)
+ .setSmr(false)
+ .setSmrInvoked(false)
+ .setSourceEid(new SourceEidBuilder().setEid(LispAddressUtil.asIpv4Eid(IPV4_SOURCE)).build())
+ .setItrRloc(getDefaultItrRlocList());
+
+ mrBuilder.getEidItem().add(new EidItemBuilder().setEid(IPV4_PREFIX_EID_1).build());
+
+ return mrBuilder;
}
- private void assertLocator(LispAddress expectedAddress, LocatorRecord locatorRecord) {
- assertEquals(expectedAddress, locatorRecord.getLocator());
- Assert.assertTrue(locatorRecord.isRouted());
+ private static MappingData getDefaultMappingData(MappingRecord mappingRecord) {
+ if (mappingRecord == null) {
+ mappingRecord = getDefaultMappingRecordBuilder().build();
+ }
+ return new MappingData(mappingRecord, System.currentTimeMillis());
}
- @Test
- public void handleMapRequest__MultipleEIDs() throws Exception {
- mapRequest.addEidRecord(new EidRecord((byte) 0, v4Address));
- mapRequest.addEidRecord(new EidRecord((byte) 0, v6Address));
-
- EidToLocatorRecord record1 = new EidToLocatorRecord().setPrefix(v4Address);
- record1.setRecordTtl(100);
- record1.addLocator(new LocatorRecord().setLocator(new LispIpv4Address(0x04030201)));
-
- EidToLocatorRecord record2 = new EidToLocatorRecord().setPrefix(v6Address);
- record2.addLocator(new LocatorRecord().setLocator(new LispIpv6Address("0:0:0:0:0:0:0:1")));
- record2.setRecordTtl(100);
- prepareMapping(record1, record2);
-
- MapReply mapReply = testedMapResolver.handleMapRequest(mapRequest);
-
- EidToLocatorRecord eidToLocators1 = mapReply.getEidToLocatorRecords().get(0);
- assertEquals(1, eidToLocators1.getLocators().size());
- assertLocator(new LispIpv4Address(0x04030201), eidToLocators1.getLocators().get(0));
-
- EidToLocatorRecord eidToLocators2 = mapReply.getEidToLocatorRecords().get(1);
- assertEquals(1, eidToLocators2.getLocators().size());
- assertLocator(new LispIpv6Address("0:0:0:0:0:0:0:1"), eidToLocators2.getLocators().get(0));
+ private static MappingRecordBuilder getDefaultMappingRecordBuilder() {
+ return new MappingRecordBuilder()
+ .setAction(MappingRecord.Action.NoAction)
+ .setAuthoritative(false)
+ .setLocatorRecord(new ArrayList<>())
+ .setMapVersion((short) 0)
+ .setRecordTtl(60)
+ .setEid(IPV4_PREFIX_EID_1);
}
- private Map<String, MappingServiceValue> prepareMapping(EidToLocatorRecord... records) {
- if (records.length > 0) {
- for (EidToLocatorRecord eidToLocatorRecord : records) {
- MappingServiceValue value = new MappingServiceValue();
- Map<String, MappingServiceValue> result = new HashMap<String, MappingServiceValue>();
- result.put("value", value);
- List<MappingServiceRLOC> rlocs = new ArrayList<MappingServiceRLOC>();
- for (LocatorRecord locator : eidToLocatorRecord.getLocators()) {
- rlocs.add(new MappingServiceRLOC(locator, eidToLocatorRecord.getRecordTtl(), eidToLocatorRecord.getAction(), eidToLocatorRecord
- .isAuthoritative()));
- }
- value.setRlocs(rlocs);
-
- daoResults.put(
- MappingServiceKeyUtil.generateMappingServiceKey(eidToLocatorRecord.getPrefix(), (byte) eidToLocatorRecord.getMaskLength()),
- result);
- }
- }
-
- ValueSaverAction<IMappingServiceKey> daoGetSaverAction = new ValueSaverAction<IMappingServiceKey>() {
- @Override
- protected boolean validate(IMappingServiceKey value) {
- return true;
- }
-
- @Override
- public Object invoke(Invocation invocation) throws Throwable {
- return daoResults.get(lastValue);
- }
- };
-
- allowing(lispDAO).get(with(daoGetSaverAction));
- will(daoGetSaverAction);
+ private static LocatorRecordBuilder getDefaultLocatorBuilder() {
+ return new LocatorRecordBuilder()
+ .setLocalLocator(false)
+ .setMulticastPriority((short) 0)
+ .setMulticastWeight((short) 0)
+ .setPriority((short) 0)
+ .setRlocProbed(false)
+ .setRouted(true)
+ .setWeight((short) 0)
+ .setKey(LOCATOR_RECORD_KEY)
+ .setRloc(LispAddressUtil.asIpv4Rloc(IPV4_RLOC_STRING_1));
+ }
- return daoResults.get(MappingServiceKeyUtil.generateMappingServiceKey(v4Address));
+ private static MapReplyBuilder getDefaultMapReplyBuilder() {
+ return new MapReplyBuilder()
+ .setEchoNonceEnabled(false)
+ .setProbe(false)
+ .setSecurityEnabled(false)
+ .setNonce(mapRequestBuilder.getNonce())
+ .setMappingRecordItem(new ArrayList<>());
}
}
Code Review / lispflowmapping.git / blobdiff