vpp-api/java/jvpp/gen/jvpp_future_facade_gen.py

   1 #!/usr/bin/env python
   2 #
   3 # Copyright (c) 2016 Cisco and/or its affiliates.
   4 # Licensed under the Apache License, Version 2.0 (the "License");
   5 # you may not use this file except in compliance with the License.
   6 # You may obtain a copy of the License at:
   7 #
   8 #     http://www.apache.org/licenses/LICENSE-2.0
   9 #
  10 # Unless required by applicable law or agreed to in writing, software
  11 # distributed under the License is distributed on an "AS IS" BASIS,
  12 # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13 # See the License for the specific language governing permissions and
  14 # limitations under the License.
  15
  16 import os
  17 from string import Template
  18
  19 import dto_gen
  20 import util
  21
  22 jvpp_facade_callback_template = Template("""
  23 package $base_package.$future_package;
  24
  25 /**
  26  * <p>Async facade callback setting values to future objects
  27  * <br>It was generated by jvpp_future_facade_gen.py based on $inputfile
  28  * <br>(python representation of vpe.api generated by vppapigen).
  29  */
  30 public final class FutureJVppFacadeCallback implements $base_package.$callback_package.JVppGlobalCallback {
  31
  32     private final java.util.Map<java.lang.Integer, java.util.concurrent.CompletableFuture<? extends $base_package.$dto_package.JVppReply<?>>> requests;
  33
  34     public FutureJVppFacadeCallback(final java.util.Map<java.lang.Integer, java.util.concurrent.CompletableFuture<? extends $base_package.$dto_package.JVppReply<?>>> requestMap) {
  35         this.requests = requestMap;
  36     }
  37
  38     @Override
  39     public void onError(org.openvpp.jvpp.VppCallbackException reply) {
  40         final java.util.concurrent.CompletableFuture<$base_package.$dto_package.JVppReply<?>> completableFuture;
  41
  42         synchronized(requests) {
  43             completableFuture = (java.util.concurrent.CompletableFuture<$base_package.$dto_package.JVppReply<?>>) requests.get(reply.getCtxId());
  44         }
  45
  46         if(completableFuture != null) {
  47             completableFuture.completeExceptionally(reply);
  48
  49             synchronized(requests) {
  50                 requests.remove(reply.getCtxId());
  51             }
  52         }
  53     }
  54
  55 $methods
  56 }
  57 """)
  58
  59 jvpp_facade_callback_method_template = Template("""
  60     @Override
  61     @SuppressWarnings("unchecked")
  62     public void on$callback_dto($base_package.$dto_package.$callback_dto reply) {
  63         final java.util.concurrent.CompletableFuture<$base_package.$dto_package.JVppReply<?>> completableFuture;
  64
  65         synchronized(requests) {
  66             completableFuture = (java.util.concurrent.CompletableFuture<$base_package.$dto_package.JVppReply<?>>) requests.get(reply.context);
  67         }
  68
  69         if(completableFuture != null) {
  70             completableFuture.complete(reply);
  71
  72             synchronized(requests) {
  73                 requests.remove(reply.context);
  74             }
  75         }
  76     }
  77 """)
  78
  79 # TODO reuse common parts with generic method callback
  80 jvpp_facade_control_ping_method_template = Template("""
  81     @Override
  82     @SuppressWarnings("unchecked")
  83     public void on$callback_dto($base_package.$dto_package.$callback_dto reply) {
  84         final java.util.concurrent.CompletableFuture<$base_package.$dto_package.JVppReply<?>> completableFuture;
  85
  86         synchronized(requests) {
  87             completableFuture = (java.util.concurrent.CompletableFuture<$base_package.$dto_package.JVppReply<?>>) requests.get(reply.context);
  88         }
  89
  90         if(completableFuture != null) {
  91             // Finish dump call
  92             if (completableFuture instanceof $base_package.$future_package.FutureJVppFacade.CompletableDumpFuture) {
  93                 completableFuture.complete((($base_package.$future_package.FutureJVppFacade.CompletableDumpFuture) completableFuture).getReplyDump());
  94                 // Remove future mapped to dump call context id
  95                 synchronized(requests) {
  96                     requests.remove((($base_package.$future_package.FutureJVppFacade.CompletableDumpFuture) completableFuture).getContextId());
  97                 }
  98             } else {
  99                 completableFuture.complete(reply);
 100             }
 101
 102             synchronized(requests) {
 103                 requests.remove(reply.context);
 104             }
 105         }
 106     }
 107 """)
 108
 109 jvpp_facade_details_callback_method_template = Template("""
 110     @Override
 111     @SuppressWarnings("unchecked")
 112     public void on$callback_dto($base_package.$dto_package.$callback_dto reply) {
 113         final FutureJVppFacade.CompletableDumpFuture<$base_package.$dto_package.$callback_dto_reply_dump> completableFuture;
 114
 115         synchronized(requests) {
 116             completableFuture = ($base_package.$future_package.FutureJVppFacade.CompletableDumpFuture<$base_package.$dto_package.$callback_dto_reply_dump>) requests.get(reply.context);
 117         }
 118
 119         if(completableFuture != null) {
 120             $base_package.$dto_package.$callback_dto_reply_dump replyDump = completableFuture.getReplyDump();
 121             if(replyDump == null) {
 122                 replyDump = new $base_package.$dto_package.$callback_dto_reply_dump();
 123                 completableFuture.setReplyDump(replyDump);
 124             }
 125
 126             replyDump.$callback_dto_field.add(reply);
 127         }
 128     }
 129 """)
 130
 131
 132 def generate_jvpp(func_list, base_package, dto_package, callback_package, future_facade_package, inputfile):
 133     """ Generates JVpp interface and JNI implementation """
 134     print "Generating JVpp future facade"
 135
 136     if not os.path.exists(future_facade_package):
 137         raise Exception("%s folder is missing" % future_facade_package)
 138
 139     methods = []
 140     methods_impl = []
 141     callbacks = []
 142     for func in func_list:
 143
 144         if util.is_notification(func['name']) or util.is_ignored(func['name']):
 145             # TODO handle notifications
 146             continue
 147
 148         camel_case_name_with_suffix = util.underscore_to_camelcase_upper(func['name'])
 149         if not util.is_reply(camel_case_name_with_suffix):
 150             continue
 151
 152         camel_case_method_name = util.underscore_to_camelcase(func['name'])
 153         camel_case_request_method_name = util.remove_reply_suffix(util.underscore_to_camelcase(func['name']))
 154         if util.is_details(camel_case_name_with_suffix):
 155             camel_case_reply_name = get_standard_dump_reply_name(util.underscore_to_camelcase_upper(func['name']),
 156                                                                    func['name'])
 157             callbacks.append(jvpp_facade_details_callback_method_template.substitute(base_package=base_package,
 158                                                                                      dto_package=dto_package,
 159                                                                                      callback_dto=camel_case_name_with_suffix,
 160                                                                                      callback_dto_field=camel_case_method_name,
 161                                                                                      callback_dto_reply_dump=camel_case_reply_name + dto_gen.dump_dto_suffix,
 162                                                                                      future_package=future_facade_package))
 163
 164             methods.append(future_jvpp_method_template.substitute(base_package=base_package,
 165                                                                   dto_package=dto_package,
 166                                                                   method_name=camel_case_request_method_name +
 167                                                                               util.underscore_to_camelcase_upper(util.dump_suffix),
 168                                                                   reply_name=camel_case_reply_name + dto_gen.dump_dto_suffix,
 169                                                                   request_name=util.remove_reply_suffix(camel_case_reply_name) +
 170                                                                                util.underscore_to_camelcase_upper(util.dump_suffix)))
 171             methods_impl.append(future_jvpp_method_impl_template.substitute(base_package=base_package,
 172                                                                             dto_package=dto_package,
 173                                                                             method_name=camel_case_request_method_name +
 174                                                                                         util.underscore_to_camelcase_upper(util.dump_suffix),
 175                                                                             reply_name=camel_case_reply_name + dto_gen.dump_dto_suffix,
 176                                                                             request_name=util.remove_reply_suffix(camel_case_reply_name) +
 177                                                                                          util.underscore_to_camelcase_upper(util.dump_suffix)))
 178         else:
 179             request_name = util.underscore_to_camelcase_upper(util.unconventional_naming_rep_req[func['name']]) \
 180                 if func['name'] in util.unconventional_naming_rep_req else util.remove_reply_suffix(camel_case_name_with_suffix)
 181
 182             methods.append(future_jvpp_method_template.substitute(base_package=base_package,
 183                                                                   dto_package=dto_package,
 184                                                                   method_name=camel_case_request_method_name,
 185                                                                   reply_name=camel_case_name_with_suffix,
 186                                                                   request_name=request_name))
 187             methods_impl.append(future_jvpp_method_impl_template.substitute(base_package=base_package,
 188                                                                             dto_package=dto_package,
 189                                                                             method_name=camel_case_request_method_name,
 190                                                                             reply_name=camel_case_name_with_suffix,
 191                                                                             request_name=request_name))
 192
 193             # Callback handler is a bit special and a different template has to be used
 194             if util.is_control_ping(camel_case_name_with_suffix):
 195                 callbacks.append(jvpp_facade_control_ping_method_template.substitute(base_package=base_package,
 196                                                                                      dto_package=dto_package,
 197                                                                                      callback_dto=camel_case_name_with_suffix,
 198                                                                                      future_package=future_facade_package))
 199             else:
 200                 callbacks.append(jvpp_facade_callback_method_template.substitute(base_package=base_package,
 201                                                                                  dto_package=dto_package,
 202                                                                                  callback_dto=camel_case_name_with_suffix))
 203
 204     jvpp_file = open(os.path.join(future_facade_package, "FutureJVppFacadeCallback.java"), 'w')
 205     jvpp_file.write(jvpp_facade_callback_template.substitute(inputfile=inputfile,
 206                                                              base_package=base_package,
 207                                                              dto_package=dto_package,
 208                                                              callback_package=callback_package,
 209                                                              methods="".join(callbacks),
 210                                                              future_package=future_facade_package))
 211     jvpp_file.flush()
 212     jvpp_file.close()
 213
 214     jvpp_file = open(os.path.join(future_facade_package, "FutureJVpp.java"), 'w')
 215     jvpp_file.write(future_jvpp_template.substitute(inputfile=inputfile,
 216                                                     base_package=base_package,
 217                                                     methods="".join(methods),
 218                                                     future_package=future_facade_package))
 219     jvpp_file.flush()
 220     jvpp_file.close()
 221
 222     jvpp_file = open(os.path.join(future_facade_package, "FutureJVppFacade.java"), 'w')
 223     jvpp_file.write(future_jvpp_facade_template.substitute(inputfile=inputfile,
 224                                                            base_package=base_package,
 225                                                            dto_package=dto_package,
 226                                                            methods="".join(methods_impl),
 227                                                            future_package=future_facade_package))
 228     jvpp_file.flush()
 229     jvpp_file.close()
 230
 231
 232 future_jvpp_template = Template('''
 233 package $base_package.$future_package;
 234
 235 /**
 236  * <p>Async facade extension adding specific methods for each request invocation
 237  * <br>It was generated by jvpp_future_facade_gen.py based on $inputfile
 238  * <br>(python representation of vpe.api generated by vppapigen).
 239  */
 240 public interface FutureJVpp extends FutureJVppInvoker {
 241 $methods
 242 }
 243 ''')
 244
 245 future_jvpp_method_template = Template('''
 246     java.util.concurrent.CompletionStage<$base_package.$dto_package.$reply_name> $method_name($base_package.$dto_package.$request_name request);
 247 ''')
 248
 249
 250 future_jvpp_facade_template = Template('''
 251 package $base_package.$future_package;
 252
 253 /**
 254  * <p>Implementation of FutureJVpp based on FutureJVppInvokerFacade
 255  * <br>It was generated by jvpp_future_facade_gen.py based on $inputfile
 256  * <br>(python representation of vpe.api generated by vppapigen).
 257  */
 258 public class FutureJVppFacade extends FutureJVppInvokerFacade implements FutureJVpp {
 259
 260     /**
 261      * <p>Create FutureJVppFacade object for provided JVpp instance.
 262      * Constructor internally creates FutureJVppFacadeCallback class for processing callbacks
 263      * and then connects to provided JVpp instance
 264      *
 265      * @param jvpp provided $base_package.JVpp instance
 266      *
 267      * @throws java.io.IOException in case instance cannot connect to JVPP
 268      */
 269     public FutureJVppFacade(final $base_package.JVpp jvpp) throws java.io.IOException {
 270         super(jvpp, new java.util.HashMap<>());
 271         jvpp.connect(new FutureJVppFacadeCallback(getRequests()));
 272     }
 273 $methods
 274 }
 275 ''')
 276
 277 future_jvpp_method_impl_template = Template('''
 278     @Override
 279     public java.util.concurrent.CompletionStage<$base_package.$dto_package.$reply_name> $method_name($base_package.$dto_package.$request_name request) {
 280         return send(request);
 281     }
 282 ''')
 283
 284 # Returns request name or special one from unconventional_naming_rep_req map
 285 def get_standard_dump_reply_name(camel_case_dto_name, func_name):
 286     # FIXME this is a hotfix for sub-details callbacks
 287     # FIXME also for L2FibTableEntry
 288     # It's all because unclear mapping between
 289     #  request -> reply,
 290     #  dump -> reply, details,
 291     #  notification_start -> reply, notifications
 292
 293     # vpe.api needs to be "standardized" so we can parse the information and create maps before generating java code
 294     suffix = func_name.split("_")[-1]
 295     return util.underscore_to_camelcase_upper(
 296         util.unconventional_naming_rep_req[func_name]) + util.underscore_to_camelcase_upper(suffix) if func_name in util.unconventional_naming_rep_req \
 297         else camel_case_dto_name