src/vpp-api/java/jvpp/gen/jvpp_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
  17 import argparse
  18 import sys
  19 import os
  20 import json
  21 import logging
  22
  23 from jvppgen import types_gen
  24 from jvppgen import callback_gen
  25 from jvppgen import notification_gen
  26 from jvppgen import dto_gen
  27 from jvppgen import jvpp_callback_facade_gen
  28 from jvppgen import jvpp_future_facade_gen
  29 from jvppgen import jvpp_impl_gen
  30 from jvppgen import jvpp_c_gen
  31 from jvppgen import util
  32 from jvppgen import enum_gen
  33
  34 # Invocation:
  35 # ~/Projects/vpp/vpp-api/jvpp/gen$ mkdir -p java/io/fd/vpp/jvpp && cd java/io/fd/vpp/jvpp
  36 # ~/Projects/vpp/vpp-api/jvpp/gen/java/io/fd/vpp/jvpp$ ../../../../jvpp_gen.py -idefs_api_vpp_papi.py
  37 #
  38 # Compilation:
  39 # ~/Projects/vpp/vpp-api/jvpp/gen/java/io/fd/vpp/jvpp$ javac *.java dto/*.java callback/*.java
  40 #
  41 # where
  42 # defs_api_vpp_papi.py - vpe.api in python format (generated by vppapigen)
  43
  44 parser = argparse.ArgumentParser(description='VPP Java API generator')
  45 parser.add_argument('-i', action="store", dest="inputfiles", nargs='+')
  46 parser.add_argument('--plugin_name', action="store", dest="plugin_name")
  47 parser.add_argument('--root_dir', action="store", dest="root_dir")
  48 args = parser.parse_args()
  49
  50 sys.path.append(".")
  51 cwd = os.getcwd()
  52
  53 # Initialize logger
  54 try:
  55     verbose = int(os.getenv("V", 0))
  56 except:
  57     verbose = 0
  58
  59 log_level = logging.WARNING
  60 if verbose == 1:
  61     log_level = logging.INFO
  62 elif verbose >= 2:
  63     log_level = logging.DEBUG
  64
  65 logging.basicConfig(stream=sys.stdout, level=log_level)
  66 logger = logging.getLogger("JVPP GEN")
  67 logger.setLevel(log_level)
  68
  69
  70 logger.info("Generating Java API for %s" % args.inputfiles)
  71 plugin_name = args.plugin_name
  72 logger.debug("plugin_name: %s" % plugin_name)
  73
  74 cfg = {}
  75
  76 base_package = 'io.fd.vpp.jvpp'
  77 plugin_package = base_package + '.' + plugin_name
  78 root_dir = os.path.abspath(args.root_dir)
  79 logger.debug("root_dir: %s" % root_dir)
  80 work_dir = root_dir + "/target/" + plugin_package.replace(".","/")
  81
  82 try:
  83     os.makedirs(work_dir)
  84 except OSError:
  85     if not os.path.isdir(work_dir):
  86         raise
  87
  88 os.chdir(work_dir)
  89
  90 for inputfile in args.inputfiles:
  91     _cfg = json.load(open(cwd + "/" + inputfile, 'r'))
  92     if 'enums' in cfg:
  93         cfg['enums'].extend(_cfg['enums'])
  94     else:
  95         cfg['enums'] = _cfg['enums']
  96     if 'types' in cfg:
  97         cfg['types'].extend(_cfg['types'])
  98     else:
  99         cfg['types'] = _cfg['types']
 100     if 'messages' in cfg:
 101         cfg['messages'].extend(_cfg['messages'])
 102     else:
 103         cfg['messages'] = _cfg['messages']
 104
 105
 106 def is_request_field(field_name):
 107     return field_name not in {'_vl_msg_id', 'client_index', 'context'}
 108
 109
 110 def is_response_field(field_name):
 111     return field_name not in {'_vl_msg_id'}
 112
 113
 114 def get_args(t, filter):
 115     arg_names = []
 116     arg_types = []
 117     for i in t:
 118         if is_crc(i):
 119             continue
 120         if not filter(i[1]):
 121             continue
 122         arg_types.append(i[0])
 123         arg_names.append(i[1])
 124     return arg_types, arg_names
 125
 126
 127 def get_types(t, filter):
 128     types_list = []
 129     lengths_list = []
 130     crc = None
 131     for i in t:
 132         if is_crc(i):
 133             crc = ('crc', i['crc'][2:])
 134             continue
 135         if not filter(i[1]):
 136             continue
 137         if len(i) is 3:  # array type
 138             types_list.append(i[0] + '[]')
 139             lengths_list.append((i[2], False))
 140         elif len(i) is 4:  # variable length array type
 141             types_list.append(i[0] + '[]')
 142             lengths_list.append((i[3], True))
 143         else:  # primitive type
 144             types_list.append(i[0])
 145             lengths_list.append((0, False))
 146     return types_list, lengths_list, crc
 147
 148
 149 def is_crc(arg):
 150     """ Check whether the argument inside message definition is just crc """
 151     return 'crc' in arg
 152
 153
 154 def get_definitions(defs):
 155     # Pass 1
 156     func_list = []
 157     func_name = {}
 158     for a in defs:
 159         java_name = util.underscore_to_camelcase(a[0])
 160
 161         # For replies include all the arguments except message_id
 162         if util.is_reply(java_name):
 163             types, lengths, crc = get_types(a[1:], is_response_field)
 164             args = get_args(a[1:], is_response_field)
 165             func_name[a[0]] = dict(
 166                 [('name', a[0]), ('java_name', java_name),
 167                  ('args', args[1]), ('arg_types', args[0]),
 168                  ('types', types), ('lengths', lengths), crc])
 169         # For requests skip message_id, client_id and context
 170         else:
 171             types, lengths, crc = get_types(a[1:], is_request_field)
 172             args = get_args(a[1:], is_request_field)
 173             func_name[a[0]] = dict(
 174                 [('name', a[0]), ('java_name', java_name),
 175                  ('args', args[1]), ('arg_types', args[0]),
 176                  ('types', types), ('lengths', lengths), crc])
 177
 178         # Indexed by name
 179         func_list.append(func_name[a[0]])
 180     return func_list, func_name
 181
 182
 183 types_package = 'types'
 184 dto_package = 'dto'
 185 callback_package = 'callback'
 186 notification_package = 'notification'
 187 future_package = 'future'
 188 # TODO find better package name
 189 callback_facade_package = 'callfacade'
 190
 191 types_list, types_name = get_definitions(cfg['types'])
 192 func_list, func_name = get_definitions(cfg['messages'])
 193
 194 enum_gen.generate_enums(cfg['enums'], args.inputfiles, logger)
 195 types_gen.generate_types(types_list, plugin_package, types_package, args.inputfiles, logger)
 196 dto_gen.generate_dtos(func_list, base_package, plugin_package, plugin_name.title(), dto_package, args.inputfiles,
 197                       logger)
 198 jvpp_impl_gen.generate_jvpp(func_list, base_package, plugin_package, plugin_name, dto_package, args.inputfiles, logger)
 199 callback_gen.generate_callbacks(func_list, base_package, plugin_package, plugin_name.title(), callback_package,
 200                                 dto_package, args.inputfiles, logger)
 201 notification_gen.generate_notification_registry(func_list, base_package, plugin_package, plugin_name.title(),
 202                                                 notification_package, callback_package, dto_package, args.inputfiles,
 203                                                 logger)
 204 jvpp_c_gen.generate_jvpp(func_list, plugin_name, args.inputfiles, root_dir, logger)
 205 jvpp_future_facade_gen.generate_jvpp(func_list, base_package, plugin_package, plugin_name.title(), dto_package,
 206                                      callback_package, notification_package, future_package, args.inputfiles, logger)
 207 jvpp_callback_facade_gen.generate_jvpp(func_list, base_package, plugin_package, plugin_name.title(), dto_package,
 208                                        callback_package, notification_package, callback_facade_package, args.inputfiles,
 209                                        logger)
 210
 211 logger.info("Java API for %s generated successfully" % args.inputfiles)