vpp-api/java/jvpp/gen/jvpp_callback_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, util
  17 from string import Template
  18
  19 import callback_gen
  20 import dto_gen
  21
  22 jvpp_ifc_template = Template("""
  23 package $base_package.$callback_facade_package;
  24
  25 /**
  26  * <p>Callback Java API representation of vpe.api.
  27  * <br>It was generated by jvpp_callback_facade_gen.py based on $inputfile
  28  * <br>(python representation of vpe.api generated by vppapigen).
  29  */
  30 public interface CallbackJVpp extends java.lang.AutoCloseable {
  31
  32     @Override
  33     void close();
  34
  35     // TODO add send
  36
  37 $methods
  38 }
  39 """)
  40
  41 jvpp_impl_template = Template("""
  42 package $base_package.$callback_facade_package;
  43
  44 /**
  45  * <p>Default implementation of CallbackJVpp interface.
  46  * <br>It was generated by jvpp_callback_facade_gen.py based on $inputfile
  47  * <br>(python representation of vpe.api generated by vppapigen).
  48  */
  49 public final class CallbackJVppFacade implements $base_package.$callback_facade_package.CallbackJVpp {
  50
  51     private final $base_package.JVpp jvpp;
  52     private final java.util.Map<Integer, $base_package.$callback_package.JVppCallback> callbacks;
  53
  54     /**
  55      * <p>Create CallbackJVppFacade object for provided JVpp instance.
  56      * Constructor internally creates CallbackJVppFacadeCallback class for processing callbacks
  57      * and then connects to provided JVpp instance
  58      *
  59      * @param jvpp provided $base_package.JVpp instance
  60      *
  61      * @throws java.io.IOException in case instance cannot connect to JVPP
  62      */
  63     public CallbackJVppFacade(final $base_package.JVpp jvpp) throws java.io.IOException {
  64         this.jvpp = java.util.Objects.requireNonNull(jvpp,"jvpp is null");
  65         this.callbacks = new java.util.HashMap<>();
  66         this.jvpp.connect(new CallbackJVppFacadeCallback(this.callbacks));
  67     }
  68
  69     @Override
  70     public void close() {
  71     }
  72
  73     // TODO add send()
  74
  75 $methods
  76 }
  77 """)
  78
  79 method_template = Template(
  80     """    void $name($base_package.$dto_package.$request request, $base_package.$callback_package.$callback callback) throws org.openvpp.jvpp.VppInvocationException;""")
  81
  82 method_impl_template = Template("""    public final void $name($base_package.$dto_package.$request request, $base_package.$callback_package.$callback callback) throws org.openvpp.jvpp.VppInvocationException {
  83         synchronized (callbacks) {
  84             callbacks.put(jvpp.$name(request), callback);
  85         }
  86     }
  87 """)
  88
  89 no_arg_method_template = Template("""    void $name($base_package.$callback_package.$callback callback) throws org.openvpp.jvpp.VppInvocationException;""")
  90 no_arg_method_impl_template = Template("""    public final void $name($base_package.$callback_package.$callback callback) throws org.openvpp.jvpp.VppInvocationException {
  91         synchronized (callbacks) {
  92             callbacks.put(jvpp.$name(), callback);
  93         }
  94     }
  95 """)
  96
  97
  98 def generate_jvpp(func_list, base_package, dto_package, callback_package, callback_facade_package, inputfile):
  99     """ Generates callback facade """
 100     print "Generating JVpp callback facade"
 101
 102     if os.path.exists(callback_facade_package):
 103         util.remove_folder(callback_facade_package)
 104
 105     os.mkdir(callback_facade_package)
 106
 107     methods = []
 108     methods_impl = []
 109     for func in func_list:
 110
 111         if util.is_notification(func['name']) or util.is_ignored(func['name']):
 112             # TODO handle notifications
 113             continue
 114
 115         camel_case_name = util.underscore_to_camelcase(func['name'])
 116         camel_case_name_upper = util.underscore_to_camelcase_upper(func['name'])
 117         if util.is_reply(camel_case_name):
 118             continue
 119
 120         # Strip suffix for dump calls
 121         callback_type = get_request_name(camel_case_name_upper, func['name']) + callback_gen.callback_suffix
 122
 123         if len(func['args']) == 0:
 124             methods.append(no_arg_method_template.substitute(name=camel_case_name,
 125                                                              base_package=base_package,
 126                                                              dto_package=dto_package,
 127                                                              callback_package=callback_package,
 128                                                              callback=callback_type))
 129             methods_impl.append(no_arg_method_impl_template.substitute(name=camel_case_name,
 130                                                                        base_package=base_package,
 131                                                                        dto_package=dto_package,
 132                                                                        callback_package=callback_package,
 133                                                                        callback=callback_type))
 134         else:
 135             methods.append(method_template.substitute(name=camel_case_name,
 136                                                       request=camel_case_name_upper,
 137                                                       base_package=base_package,
 138                                                       dto_package=dto_package,
 139                                                       callback_package=callback_package,
 140                                                       callback=callback_type))
 141             methods_impl.append(method_impl_template.substitute(name=camel_case_name,
 142                                                                 request=camel_case_name_upper,
 143                                                                 base_package=base_package,
 144                                                                 dto_package=dto_package,
 145                                                                 callback_package=callback_package,
 146                                                                 callback=callback_type))
 147
 148     join = os.path.join(callback_facade_package, "CallbackJVpp.java")
 149     jvpp_file = open(join, 'w')
 150     jvpp_file.write(
 151         jvpp_ifc_template.substitute(inputfile=inputfile,
 152                                      methods="\n".join(methods),
 153                                      base_package=base_package,
 154                                      dto_package=dto_package,
 155                                      callback_facade_package=callback_facade_package))
 156     jvpp_file.flush()
 157     jvpp_file.close()
 158
 159     jvpp_file = open(os.path.join(callback_facade_package, "CallbackJVppFacade.java"), 'w')
 160     jvpp_file.write(jvpp_impl_template.substitute(inputfile=inputfile,
 161                                                   methods="\n".join(methods_impl),
 162                                                   base_package=base_package,
 163                                                   dto_package=dto_package,
 164                                                   callback_package=callback_package,
 165                                                   callback_facade_package=callback_facade_package))
 166     jvpp_file.flush()
 167     jvpp_file.close()
 168
 169     generate_callback(func_list, base_package, dto_package, callback_package, callback_facade_package, inputfile)
 170
 171
 172 jvpp_facade_callback_template = Template("""
 173 package $base_package.$callback_facade_package;
 174
 175 /**
 176  * <p>Implementation of JVppGlobalCallback interface for Java Callback API.
 177  * <br>It was generated by jvpp_callback_facade_gen.py based on $inputfile
 178  * <br>(python representation of vpe.api generated by vppapigen).
 179  */
 180 public final class CallbackJVppFacadeCallback implements $base_package.$callback_package.JVppGlobalCallback {
 181
 182     private final java.util.Map<Integer, $base_package.$callback_package.JVppCallback> requests;
 183     private static final java.util.logging.Logger LOG = java.util.logging.Logger.getLogger(CallbackJVppFacadeCallback.class.getName());
 184
 185     public CallbackJVppFacadeCallback(final java.util.Map<Integer, $base_package.$callback_package.JVppCallback> requestMap) {
 186         this.requests = requestMap;
 187     }
 188
 189     @Override
 190     public void onError(org.openvpp.jvpp.VppCallbackException reply) {
 191
 192         $base_package.$callback_package.JVppCallback failedCall;
 193         synchronized(requests) {
 194             failedCall = requests.remove(reply.getCtxId());
 195         }
 196
 197         if(failedCall != null) {
 198             try {
 199                 failedCall.onError(reply);
 200             } catch(RuntimeException ex) {
 201                 ex.addSuppressed(reply);
 202                 LOG.log(java.util.logging.Level.WARNING, String.format("Callback: %s failed while handling exception: %s", failedCall, reply), ex);
 203             }
 204         }
 205     }
 206
 207 $methods
 208 }
 209 """)
 210
 211 jvpp_facade_callback_method_template = Template("""
 212     @Override
 213     @SuppressWarnings("unchecked")
 214     public void on$callback_dto($base_package.$dto_package.$callback_dto reply) {
 215
 216         $base_package.$callback_package.$callback callback;
 217         synchronized(requests) {
 218             callback = ($base_package.$callback_package.$callback) requests.remove(reply.context);
 219         }
 220
 221         if(callback != null) {
 222             callback.on$callback_dto(reply);
 223         }
 224     }
 225 """)
 226
 227
 228 def generate_callback(func_list, base_package, dto_package, callback_package, callback_facade_package, inputfile):
 229     callbacks = []
 230     for func in func_list:
 231
 232         if util.is_notification(func['name']) or util.is_ignored(func['name']):
 233             # TODO handle notifications
 234             continue
 235
 236         camel_case_name_with_suffix = util.underscore_to_camelcase_upper(func['name'])
 237         if not util.is_reply(camel_case_name_with_suffix):
 238             continue
 239
 240         callbacks.append(jvpp_facade_callback_method_template.substitute(base_package=base_package,
 241                                                                          dto_package=dto_package,
 242                                                                          callback_package=callback_package,
 243                                                                          callback=util.remove_reply_suffix(camel_case_name_with_suffix) + callback_gen.callback_suffix,
 244                                                                          callback_dto=camel_case_name_with_suffix))
 245
 246     jvpp_file = open(os.path.join(callback_facade_package, "CallbackJVppFacadeCallback.java"), 'w')
 247     jvpp_file.write(jvpp_facade_callback_template.substitute(inputfile=inputfile,
 248                                                              base_package=base_package,
 249                                                              dto_package=dto_package,
 250                                                              callback_package=callback_package,
 251                                                              methods="".join(callbacks),
 252                                                              callback_facade_package=callback_facade_package))
 253     jvpp_file.flush()
 254     jvpp_file.close()
 255
 256
 257 # Returns request name or special one from unconventional_naming_rep_req map
 258 def get_request_name(camel_case_dto_name, func_name):
 259     if func_name in reverse_dict(util.unconventional_naming_rep_req):
 260         request_name = util.underscore_to_camelcase_upper(reverse_dict(util.unconventional_naming_rep_req)[func_name])
 261     else:
 262         request_name = camel_case_dto_name
 263     return remove_suffix(request_name)
 264
 265
 266 def reverse_dict(map):
 267     return dict((v, k) for k, v in map.iteritems())
 268
 269
 270 def remove_suffix(name):
 271     if util.is_reply(name):
 272         return util.remove_reply_suffix(name)
 273     else:
 274         if util.is_dump(name):
 275             return util.remove_suffix(name, util.dump_suffix)
 276         else:
 277             return name