Adjust to RPC method signature update

Input/Output structures are always present and we need to return
ListenableFuture.

JIRA: TSC-99
Change-Id: I985feb0261ba73192a656c3c8803e0a258b28b80
Signed-off-by: Lorand Jakab <lojakab@cisco.com>

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 e7493eea654c5f8c62c3d15ab3b41a02db19a705..fbfb83774ea6c7ac2d5bafdc4f3a50ab8aee3721 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
@@ -9,10 +9,11 @@ package org.opendaylight.lispflowmapping.implementation;
 
 import com.google.common.base.Preconditions;
 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.Set;
-import java.util.concurrent.Future;
+
 import org.opendaylight.controller.md.sal.binding.api.DataBroker;
 import org.opendaylight.controller.md.sal.binding.api.NotificationPublishService;
 import org.opendaylight.lispflowmapping.config.ConfigIni;
@@ -35,10 +36,18 @@ import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.ma
 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;
@@ -55,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;
@@ -138,37 +166,37 @@ public class MappingService implements OdlMappingserviceService, IMappingService
     }
 
     @Override
-    public Future<RpcResult<Void>> addKey(AddKeyInput input) {
+    public ListenableFuture<RpcResult<AddKeyOutput>> addKey(AddKeyInput input) {
         Preconditions.checkNotNull(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) {
+    public ListenableFuture<RpcResult<AddMappingOutput>> addMapping(AddMappingInput input) {
         Preconditions.checkNotNull(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());
     }
@@ -200,7 +228,7 @@ public class MappingService implements OdlMappingserviceService, IMappingService
     }
 
     @Override
-    public Future<RpcResult<GetKeyOutput>> getKey(GetKeyInput input) {
+    public ListenableFuture<RpcResult<GetKeyOutput>> getKey(GetKeyInput input) {
         Preconditions.checkNotNull(input, "get-key RPC input must be not null!");
         LOG.trace("RPC received to get the following key: " + input.toString());
 
@@ -220,7 +248,7 @@ public class MappingService implements OdlMappingserviceService, IMappingService
     }
 
     @Override
-    public Future<RpcResult<GetMappingOutput>> getMapping(GetMappingInput input) {
+    public ListenableFuture<RpcResult<GetMappingOutput>> getMapping(GetMappingInput input) {
         Preconditions.checkNotNull(input, "get-mapping RPC input must be not null!");
         LOG.trace("RPC received to get the following mapping: " + input.toString());
 
@@ -266,7 +294,7 @@ public class MappingService implements OdlMappingserviceService, IMappingService
     }
 
     @Override
-    public Future<RpcResult<GetMappingWithXtrIdOutput>> getMappingWithXtrId(GetMappingWithXtrIdInput input) {
+    public ListenableFuture<RpcResult<GetMappingWithXtrIdOutput>> getMappingWithXtrId(GetMappingWithXtrIdInput input) {
         Preconditions.checkNotNull(input, "get-mapping RPC input must be not null!");
         LOG.trace("RPC received to get the following mapping: " + input.toString());
 
@@ -289,29 +317,29 @@ public class MappingService implements OdlMappingserviceService, IMappingService
     }
 
     @Override
-    public Future<RpcResult<Void>> removeKey(RemoveKeyInput input) {
+    public ListenableFuture<RpcResult<RemoveKeyOutput>> removeKey(RemoveKeyInput input) {
         Preconditions.checkNotNull(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) {
+    public ListenableFuture<RpcResult<RemoveMappingOutput>> removeMapping(RemoveMappingInput input) {
         Preconditions.checkNotNull(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());
     }
@@ -325,117 +353,118 @@ public class MappingService implements OdlMappingserviceService, IMappingService
     }
 
     @Override
-    public Future<RpcResult<Void>> updateKey(UpdateKeyInput input) {
+    public ListenableFuture<RpcResult<UpdateKeyOutput>> updateKey(UpdateKeyInput input) {
         Preconditions.checkNotNull(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!");
 
-        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
@@ -446,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());
     }

diff --git a/mappingservice/implementation/src/test/java/org/opendaylight/lispflowmapping/implementation/lisp/MappingServiceTest.java b/mappingservice/implementation/src/test/java/org/opendaylight/lispflowmapping/implementation/lisp/MappingServiceTest.java
index 83d9c2f38d80643f018929e306bc2e0b42573483..61f721de23134fc82c7ae84619f5faebddf5e51a 100644 (file)
--- a/mappingservice/implementation/src/test/java/org/opendaylight/lispflowmapping/implementation/lisp/MappingServiceTest.java
+++ b/mappingservice/implementation/src/test/java/org/opendaylight/lispflowmapping/implementation/lisp/MappingServiceTest.java
@@ -42,10 +42,16 @@ import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.ma
 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.AddKeyInputBuilder;
+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.AddMappingInput;
 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.mappingservice.rev150906.AddMappingInputBuilder;
+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.GetAllKeysInput;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.mappingservice.rev150906.GetAllMappingsInput;
 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.mappingservice.rev150906.GetKeyInput;
 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.mappingservice.rev150906.GetKeyInputBuilder;
 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.mappingservice.rev150906.GetKeyOutput;
@@ -56,17 +62,26 @@ import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.mappingservice.rev15090
 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.mappingservice.rev150906.GetMappingOutput;
 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.mappingservice.rev150906.GetMappingOutputBuilder;
 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.mappingservice.rev150906.MappingOrigin;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.mappingservice.rev150906.RemoveAllMappingsInput;
 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.mappingservice.rev150906.RemoveKeyInput;
 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.mappingservice.rev150906.RemoveKeyInputBuilder;
+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.RemoveMappingInput;
 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.mappingservice.rev150906.RemoveMappingInputBuilder;
+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.UpdateKeyInput;
 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.mappingservice.rev150906.UpdateKeyInputBuilder;
+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.UpdateMappingInput;
 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.mappingservice.rev150906.UpdateMappingInputBuilder;
+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.yangtools.yang.common.RpcError;
 import org.opendaylight.yangtools.yang.common.RpcResult;
@@ -120,7 +135,7 @@ public class MappingServiceTest {
         final RpcError error = rpc.getErrors().iterator().next();
 
         // result
-        final Future<RpcResult<Void>> result = mappingService.addKey(addKeyInput);
+        final Future<RpcResult<AddKeyOutput>> result = mappingService.addKey(addKeyInput);
         final RpcError errorResult = result.get().getErrors().iterator().next();
 
         assertEquals(1, result.get().getErrors().size());
@@ -143,12 +158,12 @@ public class MappingServiceTest {
         final AddKeyInput addKeyInput = new AddKeyInputBuilder().setEid(IPV4_EID).build();
         Mockito.when(mappingSystem.getAuthenticationKey(IPV4_EID)).thenReturn(null);
 
-        final Future<RpcResult<Void>> result = mappingService.addKey(addKeyInput);
+        final Future<RpcResult<AddKeyOutput>> result = mappingService.addKey(addKeyInput);
         Mockito.verify(dsbe).addAuthenticationKey(Mockito.any());
 
         assertEquals(RPC_RESULT_SUCCESS.getErrors(), result.get().getErrors());
-        assertEquals(RPC_RESULT_SUCCESS.getResult(), result.get().getResult());
         assertEquals(RPC_RESULT_SUCCESS.isSuccessful(), result.get().isSuccessful());
+        assertEquals(new AddKeyOutputBuilder().build(), result.get().getResult());
     }
 
     /**
@@ -160,12 +175,12 @@ public class MappingServiceTest {
         final AddMappingInput addMappingInput = new AddMappingInputBuilder()
                 .setMappingRecord(mappingRecordBuilder.build()).build();
 
-        final Future<RpcResult<Void>> result = mappingService.addMapping(addMappingInput);
+        final Future<RpcResult<AddMappingOutput>> result = mappingService.addMapping(addMappingInput);
         Mockito.verify(dsbe).addMapping(RPCInputConvertorUtil.toMapping(addMappingInput));
 
         assertEquals(RPC_RESULT_SUCCESS.getErrors(), result.get().getErrors());
-        assertEquals(RPC_RESULT_SUCCESS.getResult(), result.get().getResult());
         assertEquals(RPC_RESULT_SUCCESS.isSuccessful(), result.get().isSuccessful());
+        assertEquals(new AddMappingOutputBuilder().build(), result.get().getResult());
     }
 
     /**
@@ -276,12 +291,12 @@ public class MappingServiceTest {
     public void removeKeyTest() throws ExecutionException, InterruptedException {
         final RemoveKeyInput removeKeyInput = new RemoveKeyInputBuilder().setEid(IPV4_EID).build();
 
-        final Future<RpcResult<Void>> result = mappingService.removeKey(removeKeyInput);
+        final Future<RpcResult<RemoveKeyOutput>> result = mappingService.removeKey(removeKeyInput);
         Mockito.verify(dsbe).removeAuthenticationKey(RPCInputConvertorUtil.toAuthenticationKey(removeKeyInput));
 
         assertEquals(RPC_RESULT_SUCCESS.getErrors(), result.get().getErrors());
-        assertEquals(RPC_RESULT_SUCCESS.getResult(), result.get().getResult());
         assertEquals(RPC_RESULT_SUCCESS.isSuccessful(), result.get().isSuccessful());
+        assertEquals(new RemoveKeyOutputBuilder().build(), result.get().getResult());
     }
 
     /**
@@ -291,12 +306,12 @@ public class MappingServiceTest {
     public void removeMappingTest() throws ExecutionException, InterruptedException {
         final RemoveMappingInput removeMappingInput = new RemoveMappingInputBuilder().setEid(IPV4_EID).build();
 
-        final Future<RpcResult<Void>> result = mappingService.removeMapping(removeMappingInput);
+        final Future<RpcResult<RemoveMappingOutput>> result = mappingService.removeMapping(removeMappingInput);
         Mockito.verify(dsbe).removeMapping(RPCInputConvertorUtil.toMapping(removeMappingInput));
 
         assertEquals(RPC_RESULT_SUCCESS.getErrors(), result.get().getErrors());
-        assertEquals(RPC_RESULT_SUCCESS.getResult(), result.get().getResult());
         assertEquals(RPC_RESULT_SUCCESS.isSuccessful(), result.get().isSuccessful());
+        assertEquals(new RemoveMappingOutputBuilder().build(), result.get().getResult());
     }
 
     /**
@@ -307,12 +322,12 @@ public class MappingServiceTest {
         final UpdateKeyInput updateKeyInput = new UpdateKeyInputBuilder().setEid(IPV4_EID).build();
         Mockito.when(mappingSystem.getAuthenticationKey(IPV4_EID)).thenReturn(MAPPING_AUTHKEY);
 
-        final Future<RpcResult<Void>> result = mappingService.updateKey(updateKeyInput);
+        final Future<RpcResult<UpdateKeyOutput>> result = mappingService.updateKey(updateKeyInput);
         Mockito.verify(dsbe).updateAuthenticationKey(RPCInputConvertorUtil.toAuthenticationKey(updateKeyInput));
 
         assertEquals(RPC_RESULT_SUCCESS.getErrors(), result.get().getErrors());
-        assertEquals(RPC_RESULT_SUCCESS.getResult(), result.get().getResult());
         assertEquals(RPC_RESULT_SUCCESS.isSuccessful(), result.get().isSuccessful());
+        assertEquals(new UpdateKeyOutputBuilder().build(), result.get().getResult());
     }
 
     /**
@@ -329,7 +344,7 @@ public class MappingServiceTest {
         final RpcError error = rpc.getErrors().iterator().next();
 
         // result
-        final Future<RpcResult<Void>> result = mappingService.updateKey(updateKeyInput);
+        final Future<RpcResult<UpdateKeyOutput>> result = mappingService.updateKey(updateKeyInput);
         final RpcError errorResult = result.get().getErrors().iterator().next();
 
         assertEquals(1, result.get().getErrors().size());
@@ -353,12 +368,12 @@ public class MappingServiceTest {
         final UpdateMappingInput updateMappingInput = new UpdateMappingInputBuilder()
                 .setMappingRecord(mappingRecord).build();
 
-        final Future<RpcResult<Void>> result = mappingService.updateMapping(updateMappingInput);
+        final Future<RpcResult<UpdateMappingOutput>> result = mappingService.updateMapping(updateMappingInput);
         Mockito.verify(dsbe).updateMapping(RPCInputConvertorUtil.toMapping(updateMappingInput));
 
         assertEquals(RPC_RESULT_SUCCESS.getErrors(), result.get().getErrors());
-        assertEquals(RPC_RESULT_SUCCESS.getResult(), result.get().getResult());
         assertEquals(RPC_RESULT_SUCCESS.isSuccessful(), result.get().isSuccessful());
+        assertEquals(new UpdateMappingOutputBuilder().build(), result.get().getResult());
     }
 
     /**
@@ -526,11 +541,11 @@ public class MappingServiceTest {
         assertNull(mappingService.getKeys(Mockito.mock(GetKeysInput.class)));
         assertNull(mappingService.addMappings(Mockito.mock(AddMappingsInput.class)));
         assertNull(mappingService.updateKeys(Mockito.mock(UpdateKeysInput.class)));
-        assertNull(mappingService.removeAllMappings());
-        assertNull(mappingService.getAllKeys());
+        assertNull(mappingService.removeAllMappings(Mockito.mock(RemoveAllMappingsInput.class)));
+        assertNull(mappingService.getAllKeys(Mockito.mock(GetAllKeysInput.class)));
         assertNull(mappingService.updateMappings(Mockito.mock(UpdateMappingsInput.class)));
         assertNull(mappingService.addKeys(Mockito.mock(AddKeysInput.class)));
-        assertNull(mappingService.getAllMappings());
+        assertNull(mappingService.getAllMappings(Mockito.mock(GetAllMappingsInput.class)));
     }
 
     private static MappingData getDefaultMappingData() {

diff --git a/mappingservice/neutron/src/main/java/org/opendaylight/lispflowmapping/neutron/SubnetDataProcessor.java b/mappingservice/neutron/src/main/java/org/opendaylight/lispflowmapping/neutron/SubnetDataProcessor.java
index ef9d366774ba90dd7389616dc839b205ba5f91c1..b2c2b0d03f0691b8bf92be9449fe39d9500dfeed 100644 (file)
--- a/mappingservice/neutron/src/main/java/org/opendaylight/lispflowmapping/neutron/SubnetDataProcessor.java
+++ b/mappingservice/neutron/src/main/java/org/opendaylight/lispflowmapping/neutron/SubnetDataProcessor.java
@@ -13,8 +13,10 @@ import org.apache.commons.lang3.exception.ExceptionUtils;
 import org.opendaylight.lispflowmapping.lisp.util.LispAddressUtil;
 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.eid.container.Eid;
 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.OdlMappingserviceService;
 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.neutron.subnets.rev150712.subnets.attributes.subnets.Subnet;
 import org.opendaylight.yangtools.yang.common.RpcResult;
 import org.slf4j.Logger;
@@ -63,7 +65,7 @@ public class SubnetDataProcessor implements DataProcessor<Subnet> {
                 return;
             }
             final AddKeyInput addKeyInput = LispUtil.buildAddKeyInput(eid, subnet.getUuid().getValue());
-            final Future<RpcResult<Void>> result = lfmdb.addKey(addKeyInput);
+            final Future<RpcResult<AddKeyOutput>> result = lfmdb.addKey(addKeyInput);
             final Boolean isSuccessful = result.get().isSuccessful();
 
             if (isSuccessful) {
@@ -107,7 +109,7 @@ public class SubnetDataProcessor implements DataProcessor<Subnet> {
                 return;
             }
             final RemoveKeyInput removeKeyInput = LispUtil.buildRemoveKeyInput(eid);
-            final Future<RpcResult<Void>> result = lfmdb.removeKey(removeKeyInput);
+            final Future<RpcResult<RemoveKeyOutput>> result = lfmdb.removeKey(removeKeyInput);
             final Boolean isSuccessful = result.get().isSuccessful();
 
             if (isSuccessful) {

diff --git a/mappingservice/neutron/src/test/java/org/opendaylight/lispflowmapping/neutron/SubnetDataProcessorTest.java b/mappingservice/neutron/src/test/java/org/opendaylight/lispflowmapping/neutron/SubnetDataProcessorTest.java
index 2d531f94133e9cad57fcfcfda0baa18b0727ab05..dd6bca72d5cc8ba88a4096e8d34876b9ebb0db42 100644 (file)
--- a/mappingservice/neutron/src/test/java/org/opendaylight/lispflowmapping/neutron/SubnetDataProcessorTest.java
+++ b/mappingservice/neutron/src/test/java/org/opendaylight/lispflowmapping/neutron/SubnetDataProcessorTest.java
@@ -7,10 +7,11 @@
  */
 package org.opendaylight.lispflowmapping.neutron;
 
-import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertTrue;
 
 import java.util.concurrent.ExecutionException;
-import java.util.concurrent.Future;
+
+import com.google.common.util.concurrent.ListenableFuture;
 import org.junit.Before;
 import org.junit.Test;
 import org.mockito.Mockito;
@@ -23,9 +24,11 @@ import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.ma
 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.mappingservice.rev150906.AddKeyInput;
 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.mappingservice.rev150906.AddKeyInputBuilder;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.mappingservice.rev150906.AddKeyOutput;
 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.mappingservice.rev150906.OdlMappingserviceService;
 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.mappingservice.rev150906.RemoveKeyInput;
 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.mappingservice.rev150906.RemoveKeyInputBuilder;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.mappingservice.rev150906.RemoveKeyOutput;
 import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.subnets.rev150712.subnets.attributes.subnets.Subnet;
 import org.opendaylight.yangtools.yang.common.RpcResult;
 
@@ -34,8 +37,6 @@ public class SubnetDataProcessorTest {
     private static ILispNeutronService iLispNeutronServiceMock = Mockito.mock(ILispNeutronService.class);
     private static Subnet subnet = Mockito.mock(Subnet.class);
     private OdlMappingserviceService odlMappingserviceServiceMock;
-    private Future<RpcResult<Void>> future;
-    private RpcResult<Void> rpcResult;
 
     private static SubnetDataProcessor subnetDataProcessor = new SubnetDataProcessor(iLispNeutronServiceMock);
 
@@ -49,8 +50,6 @@ public class SubnetDataProcessorTest {
     @SuppressWarnings("unchecked")
     public void init() {
         odlMappingserviceServiceMock = Mockito.mock(OdlMappingserviceService.class);
-        future = Mockito.mock(Future.class);
-        rpcResult = Mockito.mock(RpcResult.class);
     }
 
     /**
@@ -58,16 +57,21 @@ public class SubnetDataProcessorTest {
      */
     @Test
     public void createTest() throws ExecutionException, InterruptedException {
+        ListenableFuture<RpcResult<AddKeyOutput>> future = Mockito.mock(ListenableFuture.class);
+        RpcResult<AddKeyOutput> rpcResult = Mockito.mock(RpcResult.class);
+
         final MappingAuthkey mappingAuthkey = new MappingAuthkeyBuilder()
                 .setKeyString(UUID_STRING).setKeyType(1).build();
         final AddKeyInput addKeyInput = new AddKeyInputBuilder()
                 .setEid(EID).setMappingAuthkey(mappingAuthkey).build();
 
         commonStubbing();
+        Mockito.when(future.get()).thenReturn(rpcResult);
+        Mockito.when(rpcResult.isSuccessful()).thenReturn(true);
         Mockito.when(odlMappingserviceServiceMock.addKey(addKeyInput)).thenReturn(future);
 
         subnetDataProcessor.create(subnet);
-        assertEquals(true, rpcResult.isSuccessful());
+        assertTrue(rpcResult.isSuccessful());
     }
 
     /**
@@ -88,12 +92,17 @@ public class SubnetDataProcessorTest {
     @Test
     public void deleteTest() throws ExecutionException, InterruptedException {
         final RemoveKeyInput removeKeyInput = new RemoveKeyInputBuilder().setEid(EID).build();
+        ListenableFuture<RpcResult<RemoveKeyOutput>> future = Mockito.mock(ListenableFuture.class);
+        RpcResult<RemoveKeyOutput> rpcResult = Mockito.mock(RpcResult.class);
+
 
         commonStubbing();
+        Mockito.when(future.get()).thenReturn(rpcResult);
+        Mockito.when(rpcResult.isSuccessful()).thenReturn(true);
         Mockito.when(odlMappingserviceServiceMock.removeKey(removeKeyInput)).thenReturn(future);
 
         subnetDataProcessor.delete(subnet);
-        assertEquals(true, rpcResult.isSuccessful());
+        assertTrue(rpcResult.isSuccessful());
     }
 
     /**
@@ -108,11 +117,9 @@ public class SubnetDataProcessorTest {
         Mockito.verifyZeroInteractions(odlMappingserviceServiceMock);
     }
 
-    public void commonStubbing() throws ExecutionException, InterruptedException {
+    public void commonStubbing() {
         Mockito.when(subnet.getCidr()).thenReturn(IP_PREFIX);
         Mockito.when(iLispNeutronServiceMock.getMappingDbService()).thenReturn(odlMappingserviceServiceMock);
         Mockito.when(subnet.getUuid()).thenReturn(new Uuid(UUID_STRING));
-        Mockito.when(future.get()).thenReturn(rpcResult);
-        Mockito.when(rpcResult.isSuccessful()).thenReturn(true);
     }
 }

diff --git a/mappingservice/southbound/src/main/java/org/opendaylight/lispflowmapping/southbound/LispSouthboundRPC.java b/mappingservice/southbound/src/main/java/org/opendaylight/lispflowmapping/southbound/LispSouthboundRPC.java
index 6e32befde99b0789c8b13cad11f37b5f699c8410..71b987f8a6b8cf4ead02b94e45eac9fa02e009a6 100644 (file)
--- a/mappingservice/southbound/src/main/java/org/opendaylight/lispflowmapping/southbound/LispSouthboundRPC.java
+++ b/mappingservice/southbound/src/main/java/org/opendaylight/lispflowmapping/southbound/LispSouthboundRPC.java
@@ -9,22 +9,35 @@
 package org.opendaylight.lispflowmapping.southbound;
 
 import com.google.common.util.concurrent.Futures;
+import com.google.common.util.concurrent.ListenableFuture;
 import java.nio.ByteBuffer;
 import java.util.ArrayList;
 import java.util.List;
-import java.util.concurrent.Future;
+
 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.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.MessageType;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.sb.rev150904.GetStatsInput;
 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.sb.rev150904.GetStatsOutput;
 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.sb.rev150904.GetStatsOutputBuilder;
 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.sb.rev150904.OdlLispSbService;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.sb.rev150904.ResetStatsInput;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.sb.rev150904.ResetStatsOutput;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.sb.rev150904.ResetStatsOutputBuilder;
 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.sb.rev150904.SendMapNotifyInput;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.sb.rev150904.SendMapNotifyOutput;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.sb.rev150904.SendMapNotifyOutputBuilder;
 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.sb.rev150904.SendMapRegisterInput;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.sb.rev150904.SendMapRegisterOutput;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.sb.rev150904.SendMapRegisterOutputBuilder;
 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.sb.rev150904.SendMapReplyInput;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.sb.rev150904.SendMapReplyOutput;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.sb.rev150904.SendMapReplyOutputBuilder;
 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.sb.rev150904.SendMapRequestInput;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.sb.rev150904.SendMapRequestOutput;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.sb.rev150904.SendMapRequestOutputBuilder;
 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.sb.rev150904.ctrl.msg.stats.ControlMessage;
 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.sb.rev150904.ctrl.msg.stats.ControlMessageBuilder;
 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.sb.rev150904.get.stats.output.ControlMessageStatsBuilder;
@@ -55,7 +68,7 @@ public class LispSouthboundRPC implements OdlLispSbService {
 
 
     @Override
-    public Future<RpcResult<Void>> sendMapNotify(SendMapNotifyInput mapNotifyInput) {
+    public ListenableFuture<RpcResult<SendMapNotifyOutput>> sendMapNotify(SendMapNotifyInput mapNotifyInput) {
         LOG.trace("sendMapNotify called!!");
         if (mapNotifyInput != null) {
             ByteBuffer outBuffer = MapNotifySerializer.getInstance().serialize(mapNotifyInput.getMapNotify());
@@ -63,13 +76,14 @@ public class LispSouthboundRPC implements OdlLispSbService {
                     MessageType.MapNotify);
         } else {
             LOG.warn("MapNotify was null");
-            return Futures.immediateFuture(RpcResultBuilder.<Void>failed().build());
+            return Futures.immediateFuture(RpcResultBuilder.<SendMapNotifyOutput>failed().build());
         }
-        return Futures.immediateFuture(RpcResultBuilder.<Void>success().build());
+        return Futures.immediateFuture(RpcResultBuilder.<SendMapNotifyOutput>success(
+                new SendMapNotifyOutputBuilder().build()).build());
     }
 
     @Override
-    public Future<RpcResult<Void>> sendMapReply(SendMapReplyInput mapReplyInput) {
+    public ListenableFuture<RpcResult<SendMapReplyOutput>> sendMapReply(SendMapReplyInput mapReplyInput) {
         LOG.trace("sendMapReply called!!");
         if (mapReplyInput != null) {
             ByteBuffer outBuffer = MapReplySerializer.getInstance().serialize(mapReplyInput.getMapReply());
@@ -77,13 +91,14 @@ public class LispSouthboundRPC implements OdlLispSbService {
                     MessageType.MapReply);
         } else {
             LOG.warn("MapReply was null");
-            return Futures.immediateFuture(RpcResultBuilder.<Void>failed().build());
+            return Futures.immediateFuture(RpcResultBuilder.<SendMapReplyOutput>failed().build());
         }
-        return Futures.immediateFuture(RpcResultBuilder.<Void>success().build());
+        return Futures.immediateFuture(RpcResultBuilder.<SendMapReplyOutput>success(
+                new SendMapReplyOutputBuilder().build()).build());
     }
 
     @Override
-    public Future<RpcResult<Void>> sendMapRequest(SendMapRequestInput mapRequestInput) {
+    public ListenableFuture<RpcResult<SendMapRequestOutput>> sendMapRequest(SendMapRequestInput mapRequestInput) {
         LOG.trace("sendMapRequest called!!");
         if (mapRequestInput != null) {
             ByteBuffer outBuffer = MapRequestSerializer.getInstance().serialize(mapRequestInput.getMapRequest());
@@ -91,13 +106,14 @@ public class LispSouthboundRPC implements OdlLispSbService {
                     MessageType.MapRequest);
         } else {
             LOG.debug("MapRequest was null");
-            return Futures.immediateFuture(RpcResultBuilder.<Void>failed().build());
+            return Futures.immediateFuture(RpcResultBuilder.<SendMapRequestOutput>failed().build());
         }
-        return Futures.immediateFuture(RpcResultBuilder.<Void>success().build());
+        return Futures.immediateFuture(RpcResultBuilder.<SendMapRequestOutput>success(
+                new SendMapRequestOutputBuilder().build()).build());
     }
 
     @Override
-    public Future<RpcResult<Void>> sendMapRegister(SendMapRegisterInput mapRegisterInput) {
+    public ListenableFuture<RpcResult<SendMapRegisterOutput>> sendMapRegister(SendMapRegisterInput mapRegisterInput) {
         LOG.trace("sendMapRegister called!!");
         if (mapRegisterInput != null) {
             ByteBuffer outBuffer = MapRegisterSerializer.getInstance().serialize(mapRegisterInput.getMapRegister());
@@ -105,13 +121,14 @@ public class LispSouthboundRPC implements OdlLispSbService {
                     MessageType.MapRegister);
         } else {
             LOG.debug("MapRegister was null");
-            return Futures.immediateFuture(RpcResultBuilder.<Void>failed().build());
+            return Futures.immediateFuture(RpcResultBuilder.<SendMapRegisterOutput>failed().build());
         }
-        return Futures.immediateFuture(RpcResultBuilder.<Void>success().build());
+        return Futures.immediateFuture(RpcResultBuilder.<SendMapRegisterOutput>success(
+                new SendMapRegisterOutputBuilder().build()).build());
     }
 
     @Override
-    public Future<RpcResult<GetStatsOutput>> getStats() {
+    public ListenableFuture<RpcResult<GetStatsOutput>> getStats(GetStatsInput input) {
         LOG.trace("getStats called!!");
 
         RpcResultBuilder<GetStatsOutput> rpcResultBuilder;
@@ -128,18 +145,19 @@ public class LispSouthboundRPC implements OdlLispSbService {
     }
 
     @Override
-    public Future<RpcResult<Void>> resetStats() {
+    public ListenableFuture<RpcResult<ResetStatsOutput>> resetStats(ResetStatsInput input) {
         LOG.trace("resetStats called!!");
 
         ConcurrentLispSouthboundStats stats = lispSbPlugin.getStats();
 
         if (stats == null) {
-            return Futures.immediateFuture(RpcResultBuilder.<Void>failed()
+            return Futures.immediateFuture(RpcResultBuilder.<ResetStatsOutput>failed()
                     .withError(RpcError.ErrorType.APPLICATION, "data-missing", "No stats found")
                     .build());
         } else {
             stats.resetStats();
-            return Futures.immediateFuture(RpcResultBuilder.<Void>success().build());
+            return Futures.immediateFuture(RpcResultBuilder.<ResetStatsOutput>success(
+                    new ResetStatsOutputBuilder().build()).build());
         }
     }
 

diff --git a/mappingservice/southbound/src/test/java/org/opendaylight/lispflowmapping/southbound/LispSouthboundRpcTest.java b/mappingservice/southbound/src/test/java/org/opendaylight/lispflowmapping/southbound/LispSouthboundRpcTest.java
index 3f6213d4bc44415c2f7e9e92e7b5775bf69f425d..73382eb024e5dd3102c800d92e59fafb9f66acf5 100644 (file)
--- a/mappingservice/southbound/src/test/java/org/opendaylight/lispflowmapping/southbound/LispSouthboundRpcTest.java
+++ b/mappingservice/southbound/src/test/java/org/opendaylight/lispflowmapping/southbound/LispSouthboundRpcTest.java
@@ -12,6 +12,7 @@ import static org.junit.Assert.assertEquals;
 import com.google.common.collect.Lists;
 import java.util.concurrent.ExecutionException;
 import java.util.concurrent.Future;
+
 import org.junit.Test;
 import org.junit.runner.RunWith;
 import org.mockito.InjectMocks;
@@ -36,7 +37,10 @@ import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.ma
 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.maprequestmessage.MapRequestBuilder;
 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.transport.address.TransportAddress;
 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.transport.address.TransportAddressBuilder;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.sb.rev150904.GetStatsInput;
 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.sb.rev150904.GetStatsOutput;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.sb.rev150904.ResetStatsInput;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.sb.rev150904.ResetStatsOutput;
 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.sb.rev150904.SendMapNotifyInput;
 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.sb.rev150904.SendMapRegisterInput;
 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.sb.rev150904.SendMapReplyInput;
@@ -187,7 +191,8 @@ public class LispSouthboundRpcTest {
         Mockito.when(lispSouthboundPlugin.getStats()).thenReturn(stats);
 
         // result
-        final ControlMessageStats resultStats = lispSouthboundRPC.getStats().get().getResult().getControlMessageStats();
+        final ControlMessageStats resultStats = lispSouthboundRPC.getStats(
+                Mockito.mock(GetStatsInput.class)).get().getResult().getControlMessageStats();
 
         assertEquals(stats.getRx()[0], (long) resultStats.getControlMessage().get(0).getRxCount());
         assertEquals(stats.getRx()[1], (long) resultStats.getControlMessage().get(1).getRxCount());
@@ -208,7 +213,8 @@ public class LispSouthboundRpcTest {
 
         Mockito.when(lispSouthboundPlugin.getStats()).thenReturn(null);
 
-        final Future<RpcResult<GetStatsOutput>> resultFuture = lispSouthboundRPC.getStats();
+        final Future<RpcResult<GetStatsOutput>> resultFuture = lispSouthboundRPC.getStats(
+                Mockito.mock(GetStatsInput.class));
         final RpcResult<GetStatsOutput> rpcResult = resultFuture.get();
 
         assertEquals(RPC_RESULT_ERROR.isSuccessful(), rpcResult.isSuccessful());
@@ -224,7 +230,8 @@ public class LispSouthboundRpcTest {
         incrementAll(stats);
         Mockito.when(lispSouthboundPlugin.getStats()).thenReturn(stats);
 
-        assertEquals(RPC_RESULT_SUCCESS.isSuccessful(), lispSouthboundRPC.resetStats().get().isSuccessful());
+        assertEquals(RPC_RESULT_SUCCESS.isSuccessful(), lispSouthboundRPC.resetStats(
+                Mockito.mock(ResetStatsInput.class)).get().isSuccessful());
 
         for (long rx : stats.getRx()) {
             assertEquals(0, rx);
@@ -240,8 +247,9 @@ public class LispSouthboundRpcTest {
 
         Mockito.when(lispSouthboundPlugin.getStats()).thenReturn(null);
 
-        final Future<RpcResult<Void>> resultFuture = lispSouthboundRPC.resetStats();
-        final RpcResult<Void> rpcResult = resultFuture.get();
+        final Future<RpcResult<ResetStatsOutput>> resultFuture = lispSouthboundRPC.resetStats(
+                Mockito.mock(ResetStatsInput.class));
+        final RpcResult<ResetStatsOutput> rpcResult = resultFuture.get();
 
         assertEquals(RPC_RESULT_ERROR.isSuccessful(), rpcResult.isSuccessful());
         assertEquals(expectedMsg, rpcResult.getErrors().iterator().next().getMessage());