Code Review / lispflowmapping.git / blobdiff
? search:
summary | shortlog | log | commit | commitdiff | review | tree
raw | inline | side by side
Bump MRI upstreams
[lispflowmapping.git] / mappingservice / implementation / src / main / java / org / opendaylight / lispflowmapping / implementation / MappingService.java
diff --git a/mappingservice/implementation/src/main/java/org/opendaylight/lispflowmapping/implementation/MappingService.java b/mappingservice/implementation/src/main/java/org/opendaylight/lispflowmapping/implementation/MappingService.java
index 17673e8a12d854467715b3be010be50bb0038915..86040aa35fa09f0c48c3930746a1036b4588290a 100644 (file)
--- a/mappingservice/implementation/src/main/java/org/opendaylight/lispflowmapping/implementation/MappingService.java
+++ b/mappingservice/implementation/src/main/java/org/opendaylight/lispflowmapping/implementation/MappingService.java
@@ -7,13 +7,13 @@
  */
 package org.opendaylight.lispflowmapping.implementation;
 
-import com.google.common.base.Preconditions;
+import static java.util.Objects.requireNonNull;
+
 import com.google.common.util.concurrent.Futures;
+import com.google.common.util.concurrent.ListenableFuture;
 import java.util.ArrayList;
 import java.util.List;
-import java.util.concurrent.Future;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
-import org.opendaylight.controller.md.sal.binding.api.NotificationPublishService;
+import java.util.Set;
 import org.opendaylight.lispflowmapping.config.ConfigIni;
 import org.opendaylight.lispflowmapping.dsbackend.DataStoreBackEnd;
 import org.opendaylight.lispflowmapping.implementation.mdsal.AuthenticationKeyDataListener;
@@ -21,22 +21,33 @@ import org.opendaylight.lispflowmapping.implementation.mdsal.MappingDataListener
 import org.opendaylight.lispflowmapping.implementation.util.DSBEInputUtil;
 import org.opendaylight.lispflowmapping.implementation.util.RPCInputConvertorUtil;
 import org.opendaylight.lispflowmapping.interfaces.dao.ILispDAO;
+import org.opendaylight.lispflowmapping.interfaces.dao.Subscriber;
 import org.opendaylight.lispflowmapping.interfaces.mappingservice.IMappingService;
 import org.opendaylight.lispflowmapping.lisp.type.MappingData;
 import org.opendaylight.lispflowmapping.lisp.util.LispAddressUtil;
+import org.opendaylight.mdsal.binding.api.DataBroker;
+import org.opendaylight.mdsal.binding.api.NotificationPublishService;
 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.eid.container.Eid;
 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.locatorrecords.LocatorRecord;
 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.locatorrecords.LocatorRecordBuilder;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.mapping._record.container.MappingRecord;
+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.authkey.container.MappingAuthkey;
-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.mappingservice.rev150906.AddKeyInput;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.mappingservice.rev150906.AddKeyOutput;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.mappingservice.rev150906.AddKeyOutputBuilder;
 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.mappingservice.rev150906.AddKeysInput;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.mappingservice.rev150906.AddKeysOutput;
 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.mappingservice.rev150906.AddMappingInput;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.mappingservice.rev150906.AddMappingOutput;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.mappingservice.rev150906.AddMappingOutputBuilder;
 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.mappingservice.rev150906.AddMappingsInput;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.mappingservice.rev150906.AddMappingsOutput;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.mappingservice.rev150906.GetAllKeysInput;
 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.mappingservice.rev150906.GetAllKeysOutput;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.mappingservice.rev150906.GetAllMappingsInput;
 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.mappingservice.rev150906.GetAllMappingsOutput;
 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.mappingservice.rev150906.GetKeyInput;
 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.mappingservice.rev150906.GetKeyOutput;
@@ -53,14 +64,33 @@ import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.mappingservice.rev15090
 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.mappingservice.rev150906.GetMappingsOutput;
 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.mappingservice.rev150906.MappingOrigin;
 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.mappingservice.rev150906.OdlMappingserviceService;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.mappingservice.rev150906.RemoveAllKeysInput;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.mappingservice.rev150906.RemoveAllKeysOutput;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.mappingservice.rev150906.RemoveAllMappingsInput;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.mappingservice.rev150906.RemoveAllMappingsOutput;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.mappingservice.rev150906.RemoveAllOperationalContentInput;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.mappingservice.rev150906.RemoveAllOperationalContentOutput;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.mappingservice.rev150906.RemoveAllOperationalContentOutputBuilder;
 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.mappingservice.rev150906.RemoveKeyInput;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.mappingservice.rev150906.RemoveKeyOutput;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.mappingservice.rev150906.RemoveKeyOutputBuilder;
 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.mappingservice.rev150906.RemoveKeysInput;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.mappingservice.rev150906.RemoveKeysOutput;
 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.mappingservice.rev150906.RemoveMappingInput;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.mappingservice.rev150906.RemoveMappingOutput;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.mappingservice.rev150906.RemoveMappingOutputBuilder;
 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.mappingservice.rev150906.RemoveMappingsInput;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.mappingservice.rev150906.RemoveMappingsOutput;
 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.mappingservice.rev150906.UpdateKeyInput;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.mappingservice.rev150906.UpdateKeyOutput;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.mappingservice.rev150906.UpdateKeyOutputBuilder;
 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.mappingservice.rev150906.UpdateKeysInput;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.mappingservice.rev150906.UpdateKeysOutput;
 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.mappingservice.rev150906.UpdateMappingInput;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.mappingservice.rev150906.UpdateMappingOutput;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.mappingservice.rev150906.UpdateMappingOutputBuilder;
 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.mappingservice.rev150906.UpdateMappingsInput;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.mappingservice.rev150906.UpdateMappingsOutput;
 import org.opendaylight.yangtools.yang.common.RpcError;
 import org.opendaylight.yangtools.yang.common.RpcResult;
 import org.opendaylight.yangtools.yang.common.RpcResultBuilder;
@@ -79,7 +109,7 @@ import org.slf4j.LoggerFactory;
  *
  */
 public class MappingService implements OdlMappingserviceService, IMappingService, AutoCloseable {
-    protected static final Logger LOG = LoggerFactory.getLogger(MappingService.class);
+    private static final Logger LOG = LoggerFactory.getLogger(MappingService.class);
     private static final String NOT_FOUND_TAG = "data-missing";
     private static final String DATA_EXISTS_TAG = "data-exists";
 
@@ -93,8 +123,8 @@ public class MappingService implements OdlMappingserviceService, IMappingService
     private final NotificationPublishService notificationPublishService;
 
     private boolean mappingMergePolicy = ConfigIni.getInstance().mappingMergeIsSet();
-    private boolean notificationPolicy = ConfigIni.getInstance().smrIsSet();
-    private boolean iterateMask = true;
+    private final boolean notificationPolicy = ConfigIni.getInstance().smrIsSet();
+    private final boolean iterateMask = true;
     private boolean isMaster = false;
 
     public MappingService(final DataBroker broker,
@@ -136,37 +166,37 @@ public class MappingService implements OdlMappingserviceService, IMappingService
     }
 
     @Override
-    public Future<RpcResult<Void>> addKey(AddKeyInput input) {
-        Preconditions.checkNotNull(input, "add-key RPC input must be not null!");
+    public ListenableFuture<RpcResult<AddKeyOutput>> addKey(AddKeyInput input) {
+        requireNonNull(input, "add-key RPC input must be not null!");
         LOG.trace("RPC received to add the following key: " + input.toString());
 
-        RpcResultBuilder<Void> rpcResultBuilder;
+        RpcResultBuilder<AddKeyOutput> rpcResultBuilder;
 
         MappingAuthkey key = mappingSystem.getAuthenticationKey(convertToBinaryIfNecessary(input.getEid()));
 
         if (key != null) {
             String message = "Key already exists! Please use update-key if you want to change it.";
-            rpcResultBuilder = RpcResultBuilder.<Void>failed()
+            rpcResultBuilder = RpcResultBuilder.<AddKeyOutput>failed()
                     .withError(RpcError.ErrorType.PROTOCOL, DATA_EXISTS_TAG, message);
             return Futures.immediateFuture(rpcResultBuilder.build());
         }
 
         dsbe.addAuthenticationKey(RPCInputConvertorUtil.toAuthenticationKey(input));
-        rpcResultBuilder = RpcResultBuilder.success();
+        rpcResultBuilder = RpcResultBuilder.success(new AddKeyOutputBuilder().build());
 
         return Futures.immediateFuture(rpcResultBuilder.build());
     }
 
     @Override
-    public Future<RpcResult<Void>> addMapping(AddMappingInput input) {
-        Preconditions.checkNotNull(input, "add-mapping RPC input must be not null!");
+    public ListenableFuture<RpcResult<AddMappingOutput>> addMapping(AddMappingInput input) {
+        requireNonNull(input, "add-mapping RPC input must be not null!");
         LOG.trace("RPC received to add the following mapping: " + input.toString());
 
         dsbe.addMapping(RPCInputConvertorUtil.toMapping(input));
 
-        RpcResultBuilder<Void> rpcResultBuilder;
+        RpcResultBuilder<AddMappingOutput> rpcResultBuilder;
 
-        rpcResultBuilder = RpcResultBuilder.success();
+        rpcResultBuilder = RpcResultBuilder.success(new AddMappingOutputBuilder().build());
 
         return Futures.immediateFuture(rpcResultBuilder.build());
     }
@@ -198,8 +228,8 @@ public class MappingService implements OdlMappingserviceService, IMappingService
     }
 
     @Override
-    public Future<RpcResult<GetKeyOutput>> getKey(GetKeyInput input) {
-        Preconditions.checkNotNull(input, "get-key RPC input must be not null!");
+    public ListenableFuture<RpcResult<GetKeyOutput>> getKey(GetKeyInput input) {
+        requireNonNull(input, "get-key RPC input must be not null!");
         LOG.trace("RPC received to get the following key: " + input.toString());
 
         RpcResultBuilder<GetKeyOutput> rpcResultBuilder;
@@ -218,8 +248,8 @@ public class MappingService implements OdlMappingserviceService, IMappingService
     }
 
     @Override
-    public Future<RpcResult<GetMappingOutput>> getMapping(GetMappingInput input) {
-        Preconditions.checkNotNull(input, "get-mapping RPC input must be not null!");
+    public ListenableFuture<RpcResult<GetMappingOutput>> getMapping(GetMappingInput input) {
+        requireNonNull(input, "get-mapping RPC input must be not null!");
         LOG.trace("RPC received to get the following mapping: " + input.toString());
 
         RpcResultBuilder<GetMappingOutput> rpcResultBuilder;
@@ -254,8 +284,18 @@ public class MappingService implements OdlMappingserviceService, IMappingService
     }
 
     @Override
-    public Future<RpcResult<GetMappingWithXtrIdOutput>> getMappingWithXtrId(GetMappingWithXtrIdInput input) {
-        Preconditions.checkNotNull(input, "get-mapping RPC input must be not null!");
+    public void subscribe(Subscriber subscriber, Eid subscribedEid) {
+        mappingSystem.subscribe(subscriber, subscribedEid);
+    }
+
+    @Override
+    public Set<Subscriber> getSubscribers(Eid eid) {
+        return mappingSystem.getSubscribers(eid);
+    }
+
+    @Override
+    public ListenableFuture<RpcResult<GetMappingWithXtrIdOutput>> getMappingWithXtrId(GetMappingWithXtrIdInput input) {
+        requireNonNull(input, "get-mapping RPC input must be not null!");
         LOG.trace("RPC received to get the following mapping: " + input.toString());
 
         RpcResultBuilder<GetMappingWithXtrIdOutput> rpcResultBuilder;
@@ -277,29 +317,29 @@ public class MappingService implements OdlMappingserviceService, IMappingService
     }
 
     @Override
-    public Future<RpcResult<Void>> removeKey(RemoveKeyInput input) {
-        Preconditions.checkNotNull(input, "remove-key RPC input must be not null!");
+    public ListenableFuture<RpcResult<RemoveKeyOutput>> removeKey(RemoveKeyInput input) {
+        requireNonNull(input, "remove-key RPC input must be not null!");
         LOG.trace("RPC received to remove the following key: " + input.toString());
 
-        RpcResultBuilder<Void> rpcResultBuilder;
+        RpcResultBuilder<RemoveKeyOutput> rpcResultBuilder;
 
         dsbe.removeAuthenticationKey(RPCInputConvertorUtil.toAuthenticationKey(input));
 
-        rpcResultBuilder = RpcResultBuilder.success();
+        rpcResultBuilder = RpcResultBuilder.success(new RemoveKeyOutputBuilder().build());
 
         return Futures.immediateFuture(rpcResultBuilder.build());
     }
 
     @Override
-    public Future<RpcResult<Void>> removeMapping(RemoveMappingInput input) {
-        Preconditions.checkNotNull(input, "remove-mapping RPC input must be not null!");
+    public ListenableFuture<RpcResult<RemoveMappingOutput>> removeMapping(RemoveMappingInput input) {
+        requireNonNull(input, "remove-mapping RPC input must be not null!");
         LOG.trace("RPC received to remove the following mapping: " + input.toString());
 
-        RpcResultBuilder<Void> rpcResultBuilder;
+        RpcResultBuilder<RemoveMappingOutput> rpcResultBuilder;
 
         dsbe.removeMapping(RPCInputConvertorUtil.toMapping(input));
 
-        rpcResultBuilder = RpcResultBuilder.success();
+        rpcResultBuilder = RpcResultBuilder.success(new RemoveMappingOutputBuilder().build());
 
         return Futures.immediateFuture(rpcResultBuilder.build());
     }
@@ -313,117 +353,118 @@ public class MappingService implements OdlMappingserviceService, IMappingService
     }
 
     @Override
-    public Future<RpcResult<Void>> updateKey(UpdateKeyInput input) {
-        Preconditions.checkNotNull(input, "update-key RPC input must be not null!");
+    public ListenableFuture<RpcResult<UpdateKeyOutput>> updateKey(UpdateKeyInput input) {
+        requireNonNull(input, "update-key RPC input must be not null!");
         LOG.trace("RPC received to update the following key: " + input.toString());
 
-        RpcResultBuilder<Void> rpcResultBuilder;
+        RpcResultBuilder<UpdateKeyOutput> rpcResultBuilder;
 
         MappingAuthkey key = mappingSystem.getAuthenticationKey(convertToBinaryIfNecessary(input.getEid()));
 
         if (key == null) {
             String message = "Key doesn't exist! Please use add-key if you want to create a new authentication key.";
-            rpcResultBuilder = RpcResultBuilder.<Void>failed()
+            rpcResultBuilder = RpcResultBuilder.<UpdateKeyOutput>failed()
                     .withError(RpcError.ErrorType.PROTOCOL, NOT_FOUND_TAG, message);
             return Futures.immediateFuture(rpcResultBuilder.build());
         }
 
         dsbe.updateAuthenticationKey(RPCInputConvertorUtil.toAuthenticationKey(input));
-        rpcResultBuilder = RpcResultBuilder.success();
+        rpcResultBuilder = RpcResultBuilder.success(new UpdateKeyOutputBuilder().build());
 
         return Futures.immediateFuture(rpcResultBuilder.build());
     }
 
     @Override
-    public Future<RpcResult<Void>> updateMapping(UpdateMappingInput input) {
+    public ListenableFuture<RpcResult<UpdateMappingOutput>> updateMapping(UpdateMappingInput input) {
         LOG.trace("RPC received to update the following mapping: " + input.toString());
-        Preconditions.checkNotNull(input, "update-mapping RPC input must be not null!");
+        requireNonNull(input, "update-mapping RPC input must be not null!");
 
-        RpcResultBuilder<Void> rpcResultBuilder;
+        RpcResultBuilder<UpdateMappingOutput> rpcResultBuilder;
 
         dsbe.updateMapping(RPCInputConvertorUtil.toMapping(input));
 
-        rpcResultBuilder = RpcResultBuilder.success();
+        rpcResultBuilder = RpcResultBuilder.success(new UpdateMappingOutputBuilder().build());
 
         return Futures.immediateFuture(rpcResultBuilder.build());
     }
 
     @Override
-    public Future<RpcResult<Void>> removeKeys(RemoveKeysInput input) {
+    public ListenableFuture<RpcResult<RemoveKeysOutput>> removeKeys(RemoveKeysInput input) {
         // TODO Auto-generated method stub
         return null;
     }
 
     @Override
-    public Future<RpcResult<Void>> removeMappings(RemoveMappingsInput input) {
+    public ListenableFuture<RpcResult<RemoveMappingsOutput>> removeMappings(RemoveMappingsInput input) {
         // TODO Auto-generated method stub
         return null;
     }
 
     @Override
-    public Future<RpcResult<GetKeysOutput>> getKeys(GetKeysInput input) {
+    public ListenableFuture<RpcResult<GetKeysOutput>> getKeys(GetKeysInput input) {
         // TODO Auto-generated method stub
         return null;
     }
 
     @Override
-    public Future<RpcResult<Void>> addMappings(AddMappingsInput input) {
+    public ListenableFuture<RpcResult<AddMappingsOutput>> addMappings(AddMappingsInput input) {
         // TODO Auto-generated method stub
         return null;
     }
 
     @Override
-    public Future<RpcResult<Void>> updateKeys(UpdateKeysInput input) {
+    public ListenableFuture<RpcResult<UpdateKeysOutput>> updateKeys(UpdateKeysInput input) {
         // TODO Auto-generated method stub
         return null;
     }
 
     @Override
-    public Future<RpcResult<Void>> removeAllMappings() {
+    public ListenableFuture<RpcResult<RemoveAllMappingsOutput>> removeAllMappings(RemoveAllMappingsInput input) {
         // TODO Auto-generated method stub
         return null;
     }
 
     @Override
-    public Future<RpcResult<Void>> removeAllKeys() {
+    public ListenableFuture<RpcResult<RemoveAllKeysOutput>> removeAllKeys(RemoveAllKeysInput input) {
         // TODO Auto-generated method stub
         return null;
     }
 
     @Override
-    public Future<RpcResult<GetAllKeysOutput>> getAllKeys() {
+    public ListenableFuture<RpcResult<GetAllKeysOutput>> getAllKeys(GetAllKeysInput input) {
         // TODO Auto-generated method stub
         return null;
     }
 
     @Override
-    public Future<RpcResult<Void>> updateMappings(UpdateMappingsInput input) {
+    public ListenableFuture<RpcResult<UpdateMappingsOutput>> updateMappings(UpdateMappingsInput input) {
         // TODO Auto-generated method stub
         return null;
     }
 
     @Override
-    public Future<RpcResult<Void>> addKeys(AddKeysInput input) {
+    public ListenableFuture<RpcResult<AddKeysOutput>> addKeys(AddKeysInput input) {
         // TODO Auto-generated method stub
         return null;
     }
 
     @Override
-    public Future<RpcResult<GetAllMappingsOutput>> getAllMappings() {
+    public ListenableFuture<RpcResult<GetAllMappingsOutput>> getAllMappings(GetAllMappingsInput input) {
         // TODO Auto-generated method stub
         return null;
     }
 
     @Override
-    public Future<RpcResult<GetMappingsOutput>> getMappings(
+    public ListenableFuture<RpcResult<GetMappingsOutput>> getMappings(
             GetMappingsInput input) {
         // TODO Auto-generated method stub
         return null;
     }
 
     @Override
-    public Future<RpcResult<Void>> removeAllOperationalContent() {
-        RpcResultBuilder<Void> rpcResultBuilder;
+    public ListenableFuture<RpcResult<RemoveAllOperationalContentOutput>> removeAllOperationalContent(
+            RemoveAllOperationalContentInput input) {
+        RpcResultBuilder<RemoveAllOperationalContentOutput> rpcResultBuilder;
 
         /*
          * Since master nodes ignore datastore changes for southbound originated mappings, they need to be removed
@@ -434,7 +475,7 @@ public class MappingService implements OdlMappingserviceService, IMappingService
         }
         dsbe.removeAllOperationalDatastoreContent();
 
-        rpcResultBuilder = RpcResultBuilder.success();
+        rpcResultBuilder = RpcResultBuilder.success(new RemoveAllOperationalContentOutputBuilder().build());
 
         return Futures.immediateFuture(rpcResultBuilder.build());
     }
@@ -444,6 +485,11 @@ public class MappingService implements OdlMappingserviceService, IMappingService
         return mappingSystem.getWidestNegativePrefix(key);
     }
 
+    @Override
+    public Set<Eid> getSubtree(MappingOrigin origin, Eid key) {
+        return mappingSystem.getSubtree(origin, key);
+    }
+
     @Override
     public void addAuthenticationKey(Eid key, MappingAuthkey authKey) {
         dsbe.addAuthenticationKey(DSBEInputUtil.toAuthenticationKey(key, authKey));
@@ -530,7 +576,7 @@ public class MappingService implements OdlMappingserviceService, IMappingService
         }
 
         if (LispAddressUtil.addressNeedsConversionFromBinary(originalRecord.getEid().getAddress())
-                || (originalLocators != null && convertedLocators != null)) {
+                || originalLocators != null && convertedLocators != null) {
             MappingRecordBuilder mrb = new MappingRecordBuilder(originalRecord);
             mrb.setEid(LispAddressUtil.convertFromBinary(originalRecord.getEid()));
             if (convertedLocators != null) {
@@ -548,7 +594,7 @@ public class MappingService implements OdlMappingserviceService, IMappingService
                 LocatorRecordBuilder lrb = new LocatorRecordBuilder(record);
                 lrb.setRloc(LispAddressUtil.convertFromBinary(record.getRloc()));
                 if (convertedLocators == null) {
-                    convertedLocators = new ArrayList<LocatorRecord>();
+                    convertedLocators = new ArrayList<>();
                 }
                 convertedLocators.add(lrb.build());
             }
OpenDaylight LISP Mapping Service