X-Git-Url: https://git.opendaylight.org/gerrit/gitweb?a=blobdiff_plain;f=mappingservice%2Fimplementation%2Fsrc%2Fmain%2Fjava%2Forg%2Fopendaylight%2Flispflowmapping%2Fimplementation%2FLispMappingService.java;h=cd4bfebb3349bdc8e61a3ad6798d74a3de1d7604;hb=970c3dbd56428e43f2c13f7c2fdb13dd0696aeaf;hp=2933199fab18f0c063fccddcf0da3da236f2b8a2;hpb=7e9fbe75c13692537c2b8151435c1e45223d79a9;p=lispflowmapping.git diff --git a/mappingservice/implementation/src/main/java/org/opendaylight/lispflowmapping/implementation/LispMappingService.java b/mappingservice/implementation/src/main/java/org/opendaylight/lispflowmapping/implementation/LispMappingService.java index 2933199fa..cd4bfebb3 100644 --- a/mappingservice/implementation/src/main/java/org/opendaylight/lispflowmapping/implementation/LispMappingService.java +++ b/mappingservice/implementation/src/main/java/org/opendaylight/lispflowmapping/implementation/LispMappingService.java @@ -8,67 +8,71 @@ package org.opendaylight.lispflowmapping.implementation; -import java.net.InetAddress; +import java.util.List; import org.apache.commons.lang3.tuple.MutablePair; import org.apache.commons.lang3.tuple.Pair; -import org.eclipse.osgi.framework.console.CommandInterpreter; -import org.eclipse.osgi.framework.console.CommandProvider; +import org.opendaylight.controller.md.sal.binding.api.DataBroker; +import org.opendaylight.controller.sal.binding.api.BindingAwareBroker.ProviderContext; import org.opendaylight.controller.sal.binding.api.BindingAwareBroker; -import org.opendaylight.controller.sal.binding.api.BindingAwareBroker.ConsumerContext; -import org.opendaylight.controller.sal.binding.api.BindingAwareConsumer; +import org.opendaylight.controller.sal.binding.api.BindingAwareProvider; import org.opendaylight.controller.sal.binding.api.NotificationListener; import org.opendaylight.controller.sal.binding.api.NotificationService; +import org.opendaylight.controller.sal.binding.api.RpcProviderRegistry; import org.opendaylight.lispflowmapping.implementation.config.ConfigIni; -import org.opendaylight.lispflowmapping.implementation.dao.MappingServiceKey; -import org.opendaylight.lispflowmapping.implementation.dao.MappingServiceNoMaskKey; -import org.opendaylight.lispflowmapping.implementation.inventory.IAdSalLispInventoryService; import org.opendaylight.lispflowmapping.implementation.lisp.MapResolver; import org.opendaylight.lispflowmapping.implementation.lisp.MapServer; -import org.opendaylight.lispflowmapping.implementation.serializer.LispMessage; -import org.opendaylight.lispflowmapping.implementation.util.LispAFIConvertor; +import org.opendaylight.lispflowmapping.implementation.mdsal.AuthenticationKeyDataListener; +import org.opendaylight.lispflowmapping.implementation.mdsal.DataStoreBackEnd; +import org.opendaylight.lispflowmapping.implementation.mdsal.MappingDataListener; import org.opendaylight.lispflowmapping.implementation.util.LispNotificationHelper; +import org.opendaylight.lispflowmapping.lisp.type.LispMessage; import org.opendaylight.lispflowmapping.interfaces.dao.ILispDAO; -import org.opendaylight.lispflowmapping.interfaces.dao.ILispTypeConverter; import org.opendaylight.lispflowmapping.interfaces.dao.IRowVisitor; +import org.opendaylight.lispflowmapping.interfaces.dao.SubKeys; import org.opendaylight.lispflowmapping.interfaces.lisp.IFlowMapping; +import org.opendaylight.lispflowmapping.interfaces.lisp.IFlowMappingShell; import org.opendaylight.lispflowmapping.interfaces.lisp.IMapNotifyHandler; import org.opendaylight.lispflowmapping.interfaces.lisp.IMapRequestResultHandler; import org.opendaylight.lispflowmapping.interfaces.lisp.IMapResolverAsync; import org.opendaylight.lispflowmapping.interfaces.lisp.IMapServerAsync; -import org.opendaylight.yang.gen.v1.lispflowmapping.rev131031.AddMapping; -import org.opendaylight.yang.gen.v1.lispflowmapping.rev131031.LispflowmappingService; -import org.opendaylight.yang.gen.v1.lispflowmapping.rev131031.MapNotify; -import org.opendaylight.yang.gen.v1.lispflowmapping.rev131031.MapRegister; -import org.opendaylight.yang.gen.v1.lispflowmapping.rev131031.MapReply; -import org.opendaylight.yang.gen.v1.lispflowmapping.rev131031.MapRequest; -import org.opendaylight.yang.gen.v1.lispflowmapping.rev131031.RequestMapping; -import org.opendaylight.yang.gen.v1.lispflowmapping.rev131031.SendMapNotifyInputBuilder; -import org.opendaylight.yang.gen.v1.lispflowmapping.rev131031.SendMapReplyInputBuilder; -import org.opendaylight.yang.gen.v1.lispflowmapping.rev131031.SendMapRequestInputBuilder; -import org.opendaylight.yang.gen.v1.lispflowmapping.rev131031.lispaddress.LispAddressContainer; -import org.opendaylight.yang.gen.v1.lispflowmapping.rev131031.lispaddress.LispAddressContainerBuilder; -import org.opendaylight.yang.gen.v1.lispflowmapping.rev131031.lispaddress.lispaddresscontainer.Address; -import org.opendaylight.yang.gen.v1.lispflowmapping.rev131031.lispaddress.lispaddresscontainer.address.Ipv4Builder; -import org.opendaylight.yang.gen.v1.lispflowmapping.rev131031.mapnotifymessage.MapNotifyBuilder; -import org.opendaylight.yang.gen.v1.lispflowmapping.rev131031.mapreplymessage.MapReplyBuilder; -import org.opendaylight.yang.gen.v1.lispflowmapping.rev131031.maprequestmessage.MapRequestBuilder; -import org.opendaylight.yang.gen.v1.lispflowmapping.rev131031.transportaddress.TransportAddress; -import org.opendaylight.yang.gen.v1.lispflowmapping.rev131031.transportaddress.TransportAddressBuilder; +import org.opendaylight.lispflowmapping.lisp.util.LispAFIConvertor; +import org.opendaylight.lispflowmapping.lisp.util.LispAddressStringifier; +import org.opendaylight.lispflowmapping.lisp.util.MapServerMapResolverUtil; +import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev150820.LispProtoService; +import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev150820.AddMapping; +import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev150820.MapNotify; +import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev150820.MapRegister; +import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev150820.MapReply; +import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev150820.MapRequest; +import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev150820.RequestMapping; +import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev150820.SendMapNotifyInputBuilder; +import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev150820.SendMapReplyInputBuilder; +import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev150820.SendMapRequestInputBuilder; +import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev150820.lispaddress.LispAddressContainer; +import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev150820.lispaddress.lispaddresscontainer.address.ipv4.Ipv4AddressBuilder; +import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev150820.mapnotifymessage.MapNotifyBuilder; +import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev150820.mapreplymessage.MapReplyBuilder; +import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev150820.maprequestmessage.MapRequestBuilder; +import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev150820.transportaddress.TransportAddress; +import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev150820.transportaddress.TransportAddressBuilder; +import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.mappingservice.rev150820.MappingserviceService; +import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.mappingservice.rev150820.MappingOrigin; +import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.mappingservice.rev150820.db.instance.AuthenticationKey; +import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.mappingservice.rev150820.db.instance.Mapping; import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev100924.Ipv4Address; -import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev100924.Ipv6Address; import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev100924.PortNumber; import org.opendaylight.yangtools.yang.binding.Notification; -import org.osgi.framework.BundleContext; -import org.osgi.framework.FrameworkUtil; import org.slf4j.Logger; import org.slf4j.LoggerFactory; -public class LispMappingService implements CommandProvider, IFlowMapping, BindingAwareConsumer, // - IMapRequestResultHandler, IMapNotifyHandler { - protected static final Logger logger = LoggerFactory.getLogger(LispMappingService.class); +public class LispMappingService implements IFlowMapping, IFlowMappingShell, BindingAwareProvider, + IMapRequestResultHandler, IMapNotifyHandler, AutoCloseable { + protected static final Logger LOG = LoggerFactory.getLogger(LispMappingService.class); private static final ConfigIni configIni = new ConfigIni(); + private AuthenticationKeyDataListener keyListener; + private MappingDataListener mappingListener; private ILispDAO lispDao = null; private IMapResolverAsync mapResolver; private IMapServerAsync mapServer; @@ -79,49 +83,56 @@ public class LispMappingService implements CommandProvider, IFlowMapping, Bindin private ThreadLocal tlsMapNotify = new ThreadLocal(); private ThreadLocal> tlsMapRequest = new ThreadLocal>(); - private LispflowmappingService lispSB = null; - - private ConsumerContext session; + private LispProtoService lispSB = null; + private ProviderContext session; + private DataStoreBackEnd dsbe; private NotificationService notificationService; - private IAdSalLispInventoryService inventoryService; + private static LispMappingService lfmService = null; + private BindingAwareBroker.RpcRegistration lfmDbRpc; + private DataBroker dataBrokerService; + private RpcProviderRegistry rpcRegistry; + private BindingAwareBroker broker; - class LispIpv4AddressInMemoryConverter implements ILispTypeConverter { + public LispMappingService() { + LOG.debug("LispMappingService Module starting!"); + lfmService = this; } - class LispIpv6AddressInMemoryConverter implements ILispTypeConverter { + public void setDataBrokerService(DataBroker dataBrokerService) { + this.dataBrokerService = dataBrokerService; } - class MappingServiceKeyConvertor implements ILispTypeConverter { + public void setRpcProviderRegistry(RpcProviderRegistry rpcRegistry) { + this.rpcRegistry = rpcRegistry; } - class MappingServiceNoMaskKeyConvertor implements ILispTypeConverter { + public void setBindingAwareBroker(BindingAwareBroker broker) { + this.broker = broker; } - public IAdSalLispInventoryService getInventoryService() { - return inventoryService; - } + public void initialize() { + broker.registerProvider(this); - public void setInventoryService(IAdSalLispInventoryService inventoryService) { - logger.debug("Setting inventoryService"); - this.inventoryService = inventoryService; + LfmMappingDatabaseRpc mappingDbProviderRpc = new LfmMappingDatabaseRpc(dataBrokerService); + lfmDbRpc = rpcRegistry.addRpcImplementation(MappingserviceService.class, mappingDbProviderRpc); + dsbe = new DataStoreBackEnd(dataBrokerService); + restoreDaoFromDatastore(); } - public void unsetInventoryService(IAdSalLispInventoryService inventoryService) { - logger.debug("Unsetting inventoryService"); - if (this.inventoryService == inventoryService) { - this.inventoryService = null; - } - } - - void setBindingAwareBroker(BindingAwareBroker bindingAwareBroker) { - logger.debug("BindingAwareBroker set!"); - BundleContext bundleContext = FrameworkUtil.getBundle(this.getClass()).getBundleContext(); - bindingAwareBroker.registerConsumer(this, bundleContext); + @Override + public void onSessionInitiated(ProviderContext session) { + LOG.info("Lisp Consumer session initialized!"); + notificationService = session.getSALService(NotificationService.class); + registerNotificationListener(AddMapping.class, new MapRegisterNotificationHandler()); + registerNotificationListener(RequestMapping.class, new MapRequestNotificationHandler()); + registerDataListeners(session.getSALService(DataBroker.class)); + this.session = session; + LOG.info("LISP (RFC6830) Mapping Service init finished"); } - void unsetBindingAwareBroker(BindingAwareBroker bindingAwareBroker) { - logger.debug("BindingAwareBroker was unset in LispMappingService"); + public static LispMappingService getLispMappingService() { + return lfmService; } public void basicInit(ILispDAO dao) { @@ -130,84 +141,95 @@ public class LispMappingService implements CommandProvider, IFlowMapping, Bindin mapServer = new MapServer(dao); } - void setLispDao(ILispDAO dao) { - logger.debug("LispDAO set in LispMappingService"); + public void setLispDao(ILispDAO dao) { + LOG.trace("LispDAO set in LispMappingService"); basicInit(dao); } void unsetLispDao(ILispDAO dao) { - logger.debug("LispDAO was unset in LispMappingService"); + LOG.trace("LispDAO was unset in LispMappingService"); mapServer = null; mapResolver = null; lispDao = null; } - public void init() { - try { - registerWithOSGIConsole(); - logger.info("LISP (RFC6830) Mapping Service init finished"); - } catch (Throwable t) { - logger.error(t.getStackTrace().toString()); + private void restoreDaoFromDatastore() { + List mappings = dsbe.getAllMappings(); + List authKeys = dsbe.getAllAuthenticationKeys(); + + LOG.info("Restoring {} mappings and {} keys from datastore into DAO", mappings.size(), authKeys.size()); + + // restore southbound registered entries first ... + for (Mapping mapping : mappings) { + if (mapping.getOrigin() == MappingOrigin.Southbound) { + MapRegister register = MapServerMapResolverUtil.getMapRegister(mapping); + handleMapRegister(register, false); + } + } + + // because northbound registrations have priority + for (Mapping mapping : mappings) { + if (mapping.getOrigin() == MappingOrigin.Northbound) { + MapRegister register = MapServerMapResolverUtil.getMapRegister(mapping); + handleMapRegister(register, false); + } } - } - private void registerWithOSGIConsole() { - BundleContext bundleContext = FrameworkUtil.getBundle(this.getClass()).getBundleContext(); - bundleContext.registerService(CommandProvider.class.getName(), this, null); + for (AuthenticationKey authKey : authKeys) { + addAuthenticationKey(authKey.getLispAddressContainer(), authKey.getAuthkey()); + } } public void destroy() { - logger.info("LISP (RFC6830) Mapping Service is destroyed!"); + LOG.info("LISP (RFC6830) Mapping Service is destroyed!"); mapResolver = null; mapServer = null; + closeDataListeners(); } - public void _removeEid(final CommandInterpreter ci) { - lispDao.remove(LispAFIConvertor.asIPAfiAddress(ci.nextArgument())); - } + public String printMappings() { + final StringBuffer sb = new StringBuffer(); + sb.append("EID\tRLOCs\n"); + final IRowVisitor innerVisitor = (new IRowVisitor() { + String lastKey = ""; - public void _dumpAll(final CommandInterpreter ci) { - ci.println("EID\tRLOCs"); + public void visitRow(Object keyId, String valueKey, Object value) { + String key = keyId.getClass().getSimpleName() + "#" + keyId; + if (!lastKey.equals(key)) { + sb.append(key + "\t"); + } + if (!(valueKey.equals(SubKeys.LCAF_SRCDST))) { + sb.append(valueKey + "=" + value + "\t"); + } + lastKey = key; + } + }); lispDao.getAll(new IRowVisitor() { String lastKey = ""; public void visitRow(Object keyId, String valueKey, Object value) { String key = keyId.getClass().getSimpleName() + "#" + keyId; if (!lastKey.equals(key)) { - ci.println(); - ci.print(key + "\t"); + sb.append("\n" + key + "\t"); + } + if (valueKey.equals(SubKeys.LCAF_SRCDST)) { + sb.append(valueKey + "= { "); + ((ILispDAO)value).getAll(innerVisitor); + sb.append("}\t"); + } else { + sb.append(valueKey + "=" + value + "\t"); } - ci.print(valueKey + "=" + value + "\t"); lastKey = key; } }); - ci.println(); - return; - } - - public void _setShouldOverwriteRlocs(final CommandInterpreter ci) { - try { - boolean shouldOverwriteRloc = Boolean.parseBoolean(ci.nextArgument()); - setOverwrite(shouldOverwriteRloc); - } catch (Exception e) { - ci.println("Bad Usage!!"); - } - + sb.append("\n"); + return sb.toString(); } - public void _addDefaultPassword(final CommandInterpreter ci) { - LispAddressContainerBuilder builder = new LispAddressContainerBuilder(); - builder.setAddress((Address) (new Ipv4Builder().setIpv4Address(new Ipv4Address("0.0.0.0")).build())); - addAuthenticationKey(builder.build(), 0, "password"); - } - - public String getHelp() { - StringBuffer help = new StringBuffer(); - help.append("---LISP Mapping Service---\n"); - help.append("\t dumpAll - Dump all current EID -> RLOC mapping\n"); - help.append("\t removeEid - Remove a single LispIPv4Address Eid\n"); - help.append("\t setShouldOverwritingRloc(true/false) - set the map server's behaivior regarding existing RLOCs\n"); - return help.toString(); + public void addDefaultKeyIPv4() { + LispAddressContainer address = LispAFIConvertor.toContainer( + new Ipv4AddressBuilder().setIpv4Address(new Ipv4Address("0.0.0.0")).setMask((short)0).build()); + addAuthenticationKey(address, "password"); } public MapReply handleMapRequest(MapRequest request) { @@ -215,11 +237,13 @@ public class LispMappingService implements CommandProvider, IFlowMapping, Bindin } public MapReply handleMapRequest(MapRequest request, boolean smr) { + LOG.debug("DAO: Retrieving mapping for {}", + LispAddressStringifier.getString(request.getEidRecord().get(0).getLispAddressContainer())); + tlsMapReply.set(null); tlsMapRequest.set(null); mapResolver.handleMapRequest(request, smr, this); - // After this invocation we assume that the thread local is filled with - // the reply + // After this invocation we assume that the thread local is filled with the reply if (tlsMapRequest.get() != null) { SendMapRequestInputBuilder smrib = new SendMapRequestInputBuilder(); new MapRequestBuilder(tlsMapRequest.get().getLeft()); @@ -238,23 +262,34 @@ public class LispMappingService implements CommandProvider, IFlowMapping, Bindin } public MapNotify handleMapRegister(MapRegister mapRegister, boolean smr) { + LOG.debug("DAO: Adding mapping for {}", + LispAddressStringifier.getString(mapRegister.getEidToLocatorRecord().get(0).getLispAddressContainer())); + tlsMapNotify.set(null); mapServer.handleMapRegister(mapRegister, smr, this); - // After this invocation we assume that the thread local is filled with - // the reply + // After this invocation we assume that the thread local is filled with the reply return tlsMapNotify.get(); } - public String getAuthenticationKey(LispAddressContainer address, int maskLen) { - return mapServer.getAuthenticationKey(address, maskLen); + public String getAuthenticationKey(LispAddressContainer address) { + LOG.debug("DAO: Retrieving authentication key for {}", LispAddressStringifier.getString(address)); + return mapServer.getAuthenticationKey(address); + } + + public void removeAuthenticationKey(LispAddressContainer address) { + LOG.debug("DAO: Removing authentication key for {}", LispAddressStringifier.getString(address)); + mapServer.removeAuthenticationKey(address); } - public void removeAuthenticationKey(LispAddressContainer address, int maskLen) { - mapServer.removeAuthenticationKey(address, maskLen); + public void addAuthenticationKey(LispAddressContainer address, String key) { + LOG.debug("DAO: Adding authentication key '{}' for {}", key, + LispAddressStringifier.getString(address)); + mapServer.addAuthenticationKey(address, key); } - public void addAuthenticationKey(LispAddressContainer address, int maskLen, String key) { - mapServer.addAuthenticationKey(address, maskLen, key); + public void removeMapping(LispAddressContainer address) { + LOG.debug("DAO: Removing mapping for {}", LispAddressStringifier.getString(address)); + mapServer.removeMapping(address, smr, this); } public boolean shouldIterateMask() { @@ -285,12 +320,14 @@ public class LispMappingService implements CommandProvider, IFlowMapping, Bindin return shouldAuthenticate; } - public void onSessionInitialized(ConsumerContext session) { - logger.info("Lisp Consumer session initialized!"); - notificationService = session.getSALService(NotificationService.class); - registerNotificationListener(AddMapping.class, new MapRegisterNotificationHandler()); - registerNotificationListener(RequestMapping.class, new MapRequestNotificationHandler()); - this.session = session; + private void registerDataListeners(DataBroker broker) { + keyListener = new AuthenticationKeyDataListener(broker, this); + mappingListener = new MappingDataListener(broker, this); + } + + private void closeDataListeners() { + keyListener.closeDataChangeListener(); + mappingListener.closeDataChangeListener(); } public void registerNotificationListener(Class notificationType, NotificationListener listener) { @@ -301,17 +338,17 @@ public class LispMappingService implements CommandProvider, IFlowMapping, Bindin @Override public void onNotification(AddMapping mapRegisterNotification) { - MapRegister mapRegister = mapRegisterNotification.getMapRegister(); - InetAddress address = LispNotificationHelper.getInetAddressFromIpAddress(mapRegisterNotification.getTransportAddress().getIpAddress()); - if (mapRegister.isXtrSiteIdPresent()) { - byte[] xtrId = mapRegister.getXtrId(); - inventoryService.addNode(address, xtrId); - } else { - inventoryService.addNode(address, null); - } - - MapNotify mapNotify = handleMapRegister(mapRegister, smr); + MapNotify mapNotify = handleMapRegister(mapRegisterNotification.getMapRegister(), smr); if (mapNotify != null) { + // store mappings in md-sal datastore only if we have a MapNotify + // XXX: this assumes that null MapNotifys are equivalent to authentication/registration errors + // however notifies may be disabled with a flag (by the registering router). This should + // be solved by moving southbound authentication of registrations out of handleMapRegister(). + List mappings = LispNotificationHelper.getMapping(mapRegisterNotification); + for (Mapping mapping : mappings) { + dsbe.updateMapping(mapping); + } + TransportAddressBuilder tab = new TransportAddressBuilder(); tab.setIpAddress(mapRegisterNotification.getTransportAddress().getIpAddress()); tab.setPort(new PortNumber(LispMessage.PORT_NUM)); @@ -320,7 +357,7 @@ public class LispMappingService implements CommandProvider, IFlowMapping, Bindin smnib.setTransportAddress(tab.build()); getLispSB().sendMapNotify(smnib.build()); } else { - logger.warn("got null map notify"); + LOG.warn("got null map notify"); } } @@ -337,14 +374,14 @@ public class LispMappingService implements CommandProvider, IFlowMapping, Bindin smrib.setTransportAddress(mapRequestNotification.getTransportAddress()); getLispSB().sendMapReply(smrib.build()); } else { - logger.warn("got null map reply"); + LOG.warn("got null map reply"); } } } - private LispflowmappingService getLispSB() { + private LispProtoService getLispSB() { if (lispSB == null) { - lispSB = session.getRpcService(LispflowmappingService.class); + lispSB = session.getRpcService(LispProtoService.class); } return lispSB; } @@ -358,7 +395,10 @@ public class LispMappingService implements CommandProvider, IFlowMapping, Bindin } public void handleSMR(MapRequest smr, LispAddressContainer subscriber) { - logger.debug("Sending SMR to " + subscriber.toString()); + LOG.debug("Sending SMR to {} with Source-EID {} and EID Record {}", + LispAddressStringifier.getString(subscriber), + LispAddressStringifier.getString(smr.getSourceEid().getLispAddressContainer()), + LispAddressStringifier.getString(smr.getEidRecord().get(0).getLispAddressContainer())); SendMapRequestInputBuilder smrib = new SendMapRequestInputBuilder(); smrib.setMapRequest(new MapRequestBuilder(smr).build()); smrib.setTransportAddress(LispNotificationHelper.getTransportAddressFromContainer(subscriber)); @@ -386,4 +426,9 @@ public class LispMappingService implements CommandProvider, IFlowMapping, Bindin mapServer.setOverwrite(overwrite); } + @Override + public void close() throws Exception { + lfmDbRpc.close(); + destroy(); + } }