HONEYCOMB-10: Add specific methods for each request to Future facade

These specific methods remove the need for casting on client
side code while using generic send method

Change-Id: Ic0240359333831b676a7d205f63ac1c3f3f8af4c
Signed-off-by: Maros Marsalek <mmarsale@cisco.com>

4 files changed, 116 insertions, 21 deletions

diff --git a/vpp-api/java/jvpp/gen/jvpp_future_facade_gen.py b/vpp-api/java/jvpp/gen/jvpp_future_facade_gen.py
index 60010b1070d..4f63f9bcf4b 100644
--- a/vpp-api/java/jvpp/gen/jvpp_future_facade_gen.py
+++ b/vpp-api/java/jvpp/gen/jvpp_future_facade_gen.py
@@ -13,10 +13,11 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-import os, util
+import os
 from string import Template
 
 import dto_gen
+import util
 
 jvpp_facade_callback_template = Template("""
 package $base_package.$future_package;
@@ -128,6 +129,8 @@ def generate_jvpp(func_list, base_package, dto_package, callback_package, future
     if not os.path.exists(future_facade_package):
         raise Exception("%s folder is missing" % future_facade_package)
 
+    methods = []
+    methods_impl = []
     callbacks = []
     for func in func_list:
 
@@ -139,17 +142,48 @@ def generate_jvpp(func_list, base_package, dto_package, callback_package, future
         if not util.is_reply(camel_case_name_with_suffix):
             continue
 
+        camel_case_method_name = util.underscore_to_camelcase(func['name'])
+        camel_case_request_method_name = util.remove_reply_suffix(util.underscore_to_camelcase(func['name']))
         if util.is_details(camel_case_name_with_suffix):
-            camel_case_method_name = util.underscore_to_camelcase(func['name'])
-            camel_case_request_name = get_standard_dump_reply_name(util.underscore_to_camelcase_upper(func['name']),
+            camel_case_reply_name = get_standard_dump_reply_name(util.underscore_to_camelcase_upper(func['name']),
                                                                    func['name'])
             callbacks.append(jvpp_facade_details_callback_method_template.substitute(base_package=base_package,
                                                                                      dto_package=dto_package,
                                                                                      callback_dto=camel_case_name_with_suffix,
                                                                                      callback_dto_field=camel_case_method_name,
-                                                                                     callback_dto_reply_dump=camel_case_request_name + dto_gen.dump_dto_suffix,
+                                                                                     callback_dto_reply_dump=camel_case_reply_name + dto_gen.dump_dto_suffix,
                                                                                      future_package=future_facade_package))
+
+            methods.append(future_jvpp_method_template.substitute(base_package=base_package,
+                                                                  dto_package=dto_package,
+                                                                  method_name=camel_case_request_method_name +
+                                                                              util.underscore_to_camelcase_upper(util.dump_suffix),
+                                                                  reply_name=camel_case_reply_name + dto_gen.dump_dto_suffix,
+                                                                  request_name=util.remove_reply_suffix(camel_case_reply_name) +
+                                                                               util.underscore_to_camelcase_upper(util.dump_suffix)))
+            methods_impl.append(future_jvpp_method_impl_template.substitute(base_package=base_package,
+                                                                            dto_package=dto_package,
+                                                                            method_name=camel_case_request_method_name +
+                                                                                        util.underscore_to_camelcase_upper(util.dump_suffix),
+                                                                            reply_name=camel_case_reply_name + dto_gen.dump_dto_suffix,
+                                                                            request_name=util.remove_reply_suffix(camel_case_reply_name) +
+                                                                                         util.underscore_to_camelcase_upper(util.dump_suffix)))
         else:
+            request_name = util.underscore_to_camelcase_upper(util.unconventional_naming_rep_req[func['name']]) \
+                if func['name'] in util.unconventional_naming_rep_req else util.remove_reply_suffix(camel_case_name_with_suffix)
+
+            methods.append(future_jvpp_method_template.substitute(base_package=base_package,
+                                                                  dto_package=dto_package,
+                                                                  method_name=camel_case_request_method_name,
+                                                                  reply_name=camel_case_name_with_suffix,
+                                                                  request_name=request_name))
+            methods_impl.append(future_jvpp_method_impl_template.substitute(base_package=base_package,
+                                                                            dto_package=dto_package,
+                                                                            method_name=camel_case_request_method_name,
+                                                                            reply_name=camel_case_name_with_suffix,
+                                                                            request_name=request_name))
+
+            # Callback handler is a bit special and a different template has to be used
             if util.is_control_ping(camel_case_name_with_suffix):
                 callbacks.append(jvpp_facade_control_ping_method_template.substitute(base_package=base_package,
                                                                                      dto_package=dto_package,
@@ -170,6 +204,66 @@ def generate_jvpp(func_list, base_package, dto_package, callback_package, future
     jvpp_file.flush()
     jvpp_file.close()
 
+    jvpp_file = open(os.path.join(future_facade_package, "FutureJVpp.java"), 'w')
+    jvpp_file.write(future_jvpp_template.substitute(inputfile=inputfile,
+                                                    base_package=base_package,
+                                                    methods="".join(methods),
+                                                    future_package=future_facade_package))
+    jvpp_file.flush()
+    jvpp_file.close()
+
+    jvpp_file = open(os.path.join(future_facade_package, "FutureJVppFacade.java"), 'w')
+    jvpp_file.write(future_jvpp_facade_template.substitute(inputfile=inputfile,
+                                                           base_package=base_package,
+                                                           dto_package=dto_package,
+                                                           methods="".join(methods_impl),
+                                                           future_package=future_facade_package))
+    jvpp_file.flush()
+    jvpp_file.close()
+
+
+future_jvpp_template = Template('''
+package $base_package.$future_package;
+
+/**
+ * <p>Async facade extension adding specific methods for each request invocation
+ * <br>It was generated by jvpp_future_facade_gen.py based on $inputfile
+ * <br>(python representation of vpe.api generated by vppapigen).
+ */
+public interface FutureJVpp extends FutureJVppInvoker {
+$methods
+}
+''')
+
+future_jvpp_method_template = Template('''
+    java.util.concurrent.CompletionStage<$base_package.$dto_package.$reply_name> $method_name($base_package.$dto_package.$request_name request);
+''')
+
+
+future_jvpp_facade_template = Template('''
+package $base_package.$future_package;
+
+/**
+ * <p>Implementation of FutureJVpp based on FutureJVppInvokerFacade
+ * <br>It was generated by jvpp_future_facade_gen.py based on $inputfile
+ * <br>(python representation of vpe.api generated by vppapigen).
+ */
+public class FutureJVppFacade extends FutureJVppInvokerFacade implements FutureJVpp {
+
+    public FutureJVppFacade(final $base_package.JVpp jvpp,
+                            final java.util.Map<Integer, java.util.concurrent.CompletableFuture<? extends $base_package.$dto_package.JVppReply<?>>> requestMap) {
+        super(jvpp, requestMap);
+    }
+$methods
+}
+''')
+
+future_jvpp_method_impl_template = Template('''
+    @Override
+    public java.util.concurrent.CompletionStage<$base_package.$dto_package.$reply_name> $method_name($base_package.$dto_package.$request_name request) {
+        return send(request);
+    }
+''')
 
 # Returns request name or special one from unconventional_naming_rep_req map
 def get_standard_dump_reply_name(camel_case_dto_name, func_name):
diff --git a/vpp-api/java/jvpp/org/openvpp/jvpp/future/FutureJVpp.java b/vpp-api/java/jvpp/org/openvpp/jvpp/future/FutureJVppInvoker.java
index d860bc2d483..8dab7f5e42d 100644
--- a/vpp-api/java/jvpp/org/openvpp/jvpp/future/FutureJVpp.java
+++ b/vpp-api/java/jvpp/org/openvpp/jvpp/future/FutureJVppInvoker.java
@@ -24,7 +24,7 @@ import org.openvpp.jvpp.dto.JVppRequest;
 /**
 * Future facade on top of JVpp
 */
-public interface FutureJVpp {
+public interface FutureJVppInvoker extends AutoCloseable {
 
     /**
      * Invoke asynchronous operation on VPP
diff --git a/vpp-api/java/jvpp/org/openvpp/jvpp/future/FutureJVppFacade.java b/vpp-api/java/jvpp/org/openvpp/jvpp/future/FutureJVppInvokerFacade.java
index 5b8222c4565..ef8b13c5b01 100644
--- a/vpp-api/java/jvpp/org/openvpp/jvpp/future/FutureJVppFacade.java
+++ b/vpp-api/java/jvpp/org/openvpp/jvpp/future/FutureJVppInvokerFacade.java
@@ -30,7 +30,7 @@ import org.openvpp.jvpp.dto.JVppRequest;
 /**
 * Future facade on top of JVpp
 */
-public final class FutureJVppFacade implements FutureJVpp {
+public class FutureJVppInvokerFacade implements FutureJVppInvoker {
 
     private final JVpp jvpp;
 
@@ -39,7 +39,7 @@ public final class FutureJVppFacade implements FutureJVpp {
      */
     private final Map<Integer, CompletableFuture<? extends JVppReply<?>>> requests;
 
-    public FutureJVppFacade(final JVpp jvpp,
+    public FutureJVppInvokerFacade(final JVpp jvpp,
                      final Map<Integer, CompletableFuture<? extends JVppReply<?>>> requestMap) {
         // TODO use guava's preconditions for nonNull and state checks
         // However adding guava as a dependency requires better build system for Java in VPP project
@@ -81,12 +81,9 @@ public final class FutureJVppFacade implements FutureJVpp {
     }
 
     static final class CompletableDumpFuture<T extends JVppReplyDump<?, ?>> extends CompletableFuture<T> {
-        // TODO make this final
         // The reason why this is not final is the instantiation of ReplyDump DTOs
         // Their instantiation must be generated, so currently the DTOs are created in callback and set when first dump reponses
-        // is returned. Because in callback we have method per response, but here where requests are invoked there is only
-        // a single generic send method that does not have enough information to create the DTO
-        // This can be final as soon as we provide specific send methods here
+        // is handled in the callback.
         private T replyDump;
         private final long contextId;
 
@@ -107,4 +104,8 @@ public final class FutureJVppFacade implements FutureJVpp {
         }
     }
 
+    @Override
+    public void close() throws Exception {
+        // NOOP
+    }
 }
diff --git a/vpp-api/java/jvpp/org/openvpp/jvpp/test/FutureApiTest.java b/vpp-api/java/jvpp/org/openvpp/jvpp/test/FutureApiTest.java
index b5b36d58015..eb28bbc2e4d 100644
--- a/vpp-api/java/jvpp/org/openvpp/jvpp/test/FutureApiTest.java
+++ b/vpp-api/java/jvpp/org/openvpp/jvpp/test/FutureApiTest.java
@@ -37,8 +37,8 @@ public class FutureApiTest {
     private static void testShowVersion(final FutureJVppFacade jvpp) {
         System.out.println("Sending ShowVersion request...");
         try {
-            final Future<JVppReply<ShowVersion>> replyFuture = jvpp.send(new ShowVersion()).toCompletableFuture();
-            final ShowVersionReply reply = (ShowVersionReply) replyFuture.get(); // TODO can we get rid of that cast?
+            final Future<ShowVersionReply> replyFuture = jvpp.showVersion(new ShowVersion()).toCompletableFuture();
+            final ShowVersionReply reply = replyFuture.get();
             System.out.printf("Received ShowVersionReply: context=%d, retval=%d, program=%s, " +
                             "version=%s, buildDate=%s, buildDirectory=%s\n",
                     reply.context, reply.retval, new String(reply.program), new String(reply.version),
@@ -58,8 +58,8 @@ public class FutureApiTest {
         try {
             final GetNodeIndex request = new GetNodeIndex();
             request.nodeName = "node0".getBytes();
-            final Future<JVppReply<GetNodeIndex>> replyFuture = jvpp.send(request).toCompletableFuture();
-            final GetNodeIndexReply reply = (GetNodeIndexReply) replyFuture.get();
+            final Future<GetNodeIndexReply> replyFuture = jvpp.getNodeIndex(request).toCompletableFuture();
+            final GetNodeIndexReply reply = replyFuture.get();
             System.out.printf("Received GetNodeIndexReply: context=%d, retval=%d, nodeIndex=%d\n",
                     reply.context, reply.retval, reply.nodeIndex);
         } catch (Exception e) {
@@ -74,8 +74,8 @@ public class FutureApiTest {
             final SwInterfaceDump request = new SwInterfaceDump();
             request.nameFilterValid = 0;
             request.nameFilter = "".getBytes();
-            final Future<JVppReply<SwInterfaceDump>> replyFuture = jvpp.send(request).toCompletableFuture();
-            final SwInterfaceDetailsReplyDump reply = (SwInterfaceDetailsReplyDump) replyFuture.get();
+            final Future<SwInterfaceDetailsReplyDump> replyFuture = jvpp.swInterfaceDump(request).toCompletableFuture();
+            final SwInterfaceDetailsReplyDump reply = replyFuture.get();
 
             if (reply == null) {
                 throw new IllegalStateException("SwInterfaceDetailsReplyDump is null!");
@@ -106,12 +106,12 @@ public class FutureApiTest {
         final Map<Integer, CompletableFuture<? extends JVppReply<?>>>  map = new HashMap<>();
         final org.openvpp.jvpp.JVppImpl impl =
                 new org.openvpp.jvpp.JVppImpl(VppJNIConnection.create("FutureApiTest", new FutureJVppFacadeCallback(map)));
-        final FutureJVppFacade jvpp = new FutureJVppFacade(impl, map);
+        final FutureJVppFacade jvppFacade = new FutureJVppFacade(impl, map);
         System.out.println("Successfully connected to VPP");
 
-        testShowVersion(jvpp);
-        testGetNodeIndex(jvpp);
-        testSwInterfaceDump(jvpp);
+        testShowVersion(jvppFacade);
+        testGetNodeIndex(jvppFacade);
+        testSwInterfaceDump(jvppFacade);
 
         System.out.println("Disconnecting...");
         // TODO we should consider adding jvpp.close(); to the facade