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:
8 # http://www.apache.org/licenses/LICENSE-2.0
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.
18 from string import Template
20 def is_manually_generated(f_name):
21 return f_name in {'control_ping_reply'}
24 class_reference_template = Template("""jclass ${ref_name}Class;
27 find_class_invocation_template = Template("""
28 ${ref_name}Class = (jclass)(*env)->NewGlobalRef(env, (*env)->FindClass(env, "org/openvpp/jvpp/dto/${class_name}"));
29 if ((*env)->ExceptionCheck(env)) {
30 (*env)->ExceptionDescribe(env);
34 find_class_template = Template("""
35 ${ref_name}Class = (jclass)(*env)->NewGlobalRef(env, (*env)->FindClass(env, "${class_name}"));
36 if ((*env)->ExceptionCheck(env)) {
37 (*env)->ExceptionDescribe(env);
41 class_cache_template = Template("""
43 static int cache_class_references(JNIEnv* env) {
44 $find_class_invocations
48 def generate_class_cache(func_list):
50 find_class_invocations = []
53 class_name = util.underscore_to_camelcase_upper(c_name)
54 ref_name = util.underscore_to_camelcase(c_name)
56 if util.is_ignored(c_name):
59 if util.is_reply(class_name):
60 class_references.append(class_reference_template.substitute(
62 find_class_invocations.append(find_class_invocation_template.substitute(
64 class_name=class_name))
65 elif util.is_notification(c_name):
66 class_references.append(class_reference_template.substitute(
67 ref_name=util.add_notification_suffix(ref_name)))
68 find_class_invocations.append(find_class_invocation_template.substitute(
69 ref_name=util.add_notification_suffix(ref_name),
70 class_name=util.add_notification_suffix(class_name)))
72 # add exception class to class cache
73 ref_name = 'callbackException'
74 class_name = 'org/openvpp/jvpp/VppCallbackException'
75 class_references.append(class_reference_template.substitute(
77 find_class_invocations.append(find_class_template.substitute(
79 class_name=class_name))
80 return class_cache_template.substitute(
81 class_references="".join(class_references), find_class_invocations="".join(find_class_invocations))
84 # TODO: cache method and field identifiers to achieve better performance
85 # https://jira.fd.io/browse/HONEYCOMB-42
86 request_class_template = Template("""
87 jclass requestClass = (*env)->FindClass(env, "org/openvpp/jvpp/dto/${java_name_upper}");""")
89 request_field_identifier_template = Template("""
90 jfieldID ${java_name}FieldId = (*env)->GetFieldID(env, requestClass, "${java_name}", "${jni_signature}");
91 ${jni_type} ${java_name} = (*env)->Get${jni_getter}(env, request, ${java_name}FieldId);
94 u8_struct_setter_template = Template("""
95 mp->${c_name} = ${java_name};""")
97 u16_struct_setter_template = Template("""
98 mp->${c_name} = clib_host_to_net_u16(${java_name});""")
100 u32_struct_setter_template = Template("""
101 mp->${c_name} = clib_host_to_net_u32(${java_name});""")
103 i32_struct_setter_template = Template("""
104 mp->${c_name} = clib_host_to_net_i32(${java_name});!""")
106 u64_struct_setter_template = Template("""
107 mp->${c_name} = clib_host_to_net_u64(${java_name});""")
109 u8_array_struct_setter_template = Template("""
111 jsize cnt = (*env)->GetArrayLength (env, ${java_name});
112 size_t max_size = ${field_length};
113 if (max_size != 0 && cnt > max_size) cnt = max_size;
114 (*env)->GetByteArrayRegion(env, ${java_name}, 0, cnt, (jbyte *)mp->${c_name});
118 u16_array_struct_setter_template = Template("""
119 jshort * ${java_name}ArrayElements = (*env)->GetShortArrayElements(env, ${java_name}, NULL);
122 jsize cnt = (*env)->GetArrayLength (env, ${java_name});
123 size_t max_size = ${field_length};
124 if (max_size != 0 && cnt > max_size) cnt = max_size;
125 for (_i = 0; _i < cnt; _i++) {
126 mp->${c_name}[_i] = clib_host_to_net_u16(${java_name}ArrayElements[_i]);
129 (*env)->ReleaseShortArrayElements (env, ${java_name}, ${java_name}ArrayElements, 0);
132 u32_array_struct_setter_template = Template("""
133 jint * ${java_name}ArrayElements = (*env)->GetIntArrayElements(env, ${java_name}, NULL);
136 jsize cnt = (*env)->GetArrayLength (env, ${java_name});
137 size_t max_size = ${field_length};
138 if (max_size != 0 && cnt > max_size) cnt = max_size;
139 for (_i = 0; _i < cnt; _i++) {
140 mp->${c_name}[_i] = clib_host_to_net_u32(${java_name}ArrayElements[_i]);
143 (*env)->ReleaseIntArrayElements (env, ${java_name}, ${java_name}ArrayElements, 0);
146 u64_array_struct_setter_template = Template("""
147 jlong * ${java_name}ArrayElements = (*env)->GetLongArrayElements(env, ${java_name}, NULL);
150 jsize cnt = (*env)->GetArrayLength (env, ${java_name});
151 size_t max_size = ${field_length};
152 if (max_size != 0 && cnt > max_size) cnt = max_size;
153 for (_i = 0; _i < cnt; _i++) {
154 mp->${c_name}[_i] = clib_host_to_net_u64(${java_name}ArrayElements[_i]);
157 (*env)->ReleaseLongArrayElements (env, ${java_name}, ${java_name}ArrayElements, 0);
160 vl_api_ip4_fib_counter_t_array_struct_setter_template = Template("""
161 // vl_api_ip4_fib_counter_t_array_field_setter_template FIXME""")
163 vl_api_ip6_fib_counter_t_array_struct_setter_template = Template("""
164 // vl_api_ip6_fib_counter_t_array_field_setter_template FIXME""")
166 struct_setter_templates = {'u8': u8_struct_setter_template,
167 'u16': u16_struct_setter_template,
168 'u32': u32_struct_setter_template,
169 'i32': u32_struct_setter_template,
170 'u64': u64_struct_setter_template,
171 'u8[]': u8_array_struct_setter_template,
172 'u16[]': u16_array_struct_setter_template,
173 'u32[]': u32_array_struct_setter_template,
174 'u64[]': u64_array_struct_setter_template,
175 'vl_api_ip4_fib_counter_t[]': vl_api_ip4_fib_counter_t_array_struct_setter_template,
176 'vl_api_ip6_fib_counter_t[]': vl_api_ip6_fib_counter_t_array_struct_setter_template
179 jni_impl_template = Template("""
181 * JNI binding for sending ${c_name} vpe.api message.
182 * Generated based on $inputfile preparsed data:
185 JNIEXPORT jint JNICALL Java_org_openvpp_jvpp_JVppImpl_${java_name}0
186 (JNIEnv * env, jclass clazz$args) {
187 vppjni_main_t *jm = &vppjni_main;
188 vl_api_${c_name}_t * mp;
191 rv = vppjni_sanity_check (jm);
193 my_context_id = vppjni_get_context_id (jm);
196 M(${c_name_uppercase}, ${c_name});
197 mp->context = clib_host_to_net_u32 (my_context_id);
200 if ((*env)->ExceptionCheck(env)) {
203 return my_context_id;
206 def generate_jni_impl(func_list, inputfile):
210 camel_case_function_name = util.underscore_to_camelcase(f_name)
211 if is_manually_generated(f_name) or util.is_reply(camel_case_function_name) \
212 or util.is_ignored(f_name) or util.is_just_notification(f_name):
217 field_identifiers = ''
219 f_name_uppercase = f_name.upper()
222 arguments = ', jobject request'
223 camel_case_function_name_upper = util.underscore_to_camelcase_upper(f_name)
225 request_class = request_class_template.substitute(java_name_upper=camel_case_function_name_upper)
228 for t in zip(f['types'], f['args']):
230 java_field_name = util.underscore_to_camelcase(t[1])
231 jni_signature = util.jni_2_signature_mapping[jni_type]
232 jni_getter = util.jni_field_accessors[jni_type]
233 field_identifiers += request_field_identifier_template.substitute(
235 java_name=java_field_name,
236 jni_signature=jni_signature,
237 jni_getter=jni_getter)
240 for t in zip(f['c_types'], f['args'], f['lengths']):
243 field_length = t[2][0]
245 # check if we are processing variable length array:
247 field_length = util.underscore_to_camelcase(t[2][0])
249 java_field_name = util.underscore_to_camelcase(c_name)
251 struct_setter_template = struct_setter_templates[c_type]
253 struct_setters += struct_setter_template.substitute(
255 java_name=java_field_name,
256 field_length=field_length)
258 jni_impl.append(jni_impl_template.substitute(
260 api_data=util.api_message_to_javadoc(f),
261 java_name=camel_case_function_name,
262 c_name_uppercase=f_name_uppercase,
264 request_class=request_class,
265 field_identifiers=field_identifiers,
266 struct_setters=struct_setters,
269 return "\n".join(jni_impl)
272 dto_field_id_template = Template("""
273 jfieldID ${java_name}FieldId = (*env)->GetFieldID(env, ${class_ref_name}Class, "${java_name}", "${jni_signature}");""")
275 default_dto_field_setter_template = Template("""
276 (*env)->Set${jni_setter}(env, dto, ${java_name}FieldId, mp->${c_name});
279 variable_length_array_value_template = Template("""mp->${length_var_name}""")
280 variable_length_array_template = Template("""clib_net_to_host_${length_field_type}(${value})""")
282 u16_dto_field_setter_template = Template("""
283 (*env)->Set${jni_setter}(env, dto, ${java_name}FieldId, clib_net_to_host_u16(mp->${c_name}));
286 u32_dto_field_setter_template = Template("""
287 (*env)->Set${jni_setter}(env, dto, ${java_name}FieldId, clib_net_to_host_u32(mp->${c_name}));
290 u64_dto_field_setter_template = Template("""
291 (*env)->Set${jni_setter}(env, dto, ${java_name}FieldId, clib_net_to_host_u64(mp->${c_name}));
294 u8_array_dto_field_setter_template = Template("""
295 jbyteArray ${java_name} = (*env)->NewByteArray(env, ${field_length});
296 (*env)->SetByteArrayRegion(env, ${java_name}, 0, ${field_length}, (const jbyte*)mp->${c_name});
297 (*env)->SetObjectField(env, dto, ${java_name}FieldId, ${java_name});
300 u16_array_dto_field_setter_template = Template("""
302 jshortArray ${java_name} = (*env)->NewShortArray(env, ${field_length});
303 jshort * ${java_name}ArrayElements = (*env)->GetShortArrayElements(env, ${java_name}, NULL);
305 for (_i = 0; _i < ${field_length}; _i++) {
306 ${java_name}ArrayElements[_i] = clib_net_to_host_u16(mp->${c_name}[_i]);
309 (*env)->ReleaseShortArrayElements(env, ${java_name}, ${java_name}ArrayElements, 0);
310 (*env)->SetObjectField(env, dto, ${java_name}FieldId, ${java_name});
314 u32_array_dto_field_setter_template = Template("""
316 jintArray ${java_name} = (*env)->NewIntArray(env, ${field_length});
317 jint * ${java_name}ArrayElements = (*env)->GetIntArrayElements(env, ${java_name}, NULL);
319 for (_i = 0; _i < ${field_length}; _i++) {
320 ${java_name}ArrayElements[_i] = clib_net_to_host_u32(mp->${c_name}[_i]);
323 (*env)->ReleaseIntArrayElements(env, ${java_name}, ${java_name}ArrayElements, 0);
324 (*env)->SetObjectField(env, dto, ${java_name}FieldId, ${java_name});
328 # For each u64 array we get its elements. Then we convert values to host byte order.
329 # All changes to jlong* buffer are written to jlongArray (isCopy is set to NULL)
330 u64_array_dto_field_setter_template = Template("""
332 jlongArray ${java_name} = (*env)->NewLongArray(env, ${field_length});
333 jlong * ${java_name}ArrayElements = (*env)->GetLongArrayElements(env, ${java_name}, NULL);
335 for (_i = 0; _i < ${field_length}; _i++) {
336 ${java_name}ArrayElements[_i] = clib_net_to_host_u64(mp->${c_name}[_i]);
339 (*env)->ReleaseLongArrayElements(env, ${java_name}, ${java_name}ArrayElements, 0);
340 (*env)->SetObjectField(env, dto, ${java_name}FieldId, ${java_name});
344 dto_field_setter_templates = {'u8': default_dto_field_setter_template,
345 'u16': u16_dto_field_setter_template,
346 'u32': u32_dto_field_setter_template,
347 'i32': u32_dto_field_setter_template,
348 'u64': u64_dto_field_setter_template,
349 'f64': default_dto_field_setter_template, #fixme
350 'u8[]': u8_array_dto_field_setter_template,
351 'u16[]': u16_array_dto_field_setter_template,
352 'u32[]': u32_array_dto_field_setter_template,
353 'u64[]': u64_array_dto_field_setter_template
356 # code fragment for checking result of the operation before sending request reply
357 callback_err_handler_template = Template("""
358 // for negative result don't send callback message but send error callback
360 CallOnError("${handler_name}",mp->context,mp->retval);
363 if (mp->retval == VNET_API_ERROR_IN_PROGRESS) {
364 clib_warning("Result in progress");
369 msg_handler_template = Template("""
371 * Handler for ${handler_name} vpe.api message.
372 * Generated based on $inputfile preparsed data:
375 static void vl_api_${handler_name}_t_handler (vl_api_${handler_name}_t * mp)
377 vppjni_main_t * jm = &vppjni_main;
378 JNIEnv *env = jm->jenv;
381 jmethodID constructor = (*env)->GetMethodID(env, ${class_ref_name}Class, "<init>", "()V");
382 jmethodID callbackMethod = (*env)->GetMethodID(env, jm->callbackClass, "on${dto_name}", "(Lorg/openvpp/jvpp/dto/${dto_name};)V");
384 jobject dto = (*env)->NewObject(env, ${class_ref_name}Class, constructor);
386 (*env)->CallVoidMethod(env, jm->callback, callbackMethod, dto);
389 def generate_msg_handlers(func_list, inputfile):
392 handler_name = f['name']
393 dto_name = util.underscore_to_camelcase_upper(handler_name)
394 ref_name = util.underscore_to_camelcase(handler_name)
396 if is_manually_generated(handler_name) or util.is_ignored(handler_name):
399 if not util.is_reply(dto_name) and not util.is_notification(handler_name):
402 if util.is_notification(handler_name):
403 dto_name = util.add_notification_suffix(dto_name)
404 ref_name = util.add_notification_suffix(ref_name)
409 for t in zip(f['c_types'], f['types'], f['args'], f['lengths']):
413 field_length = t[3][0]
415 # check if we are processing variable length array
417 length_var_name = t[3][0]
418 length_field_type = f['c_types'][f['args'].index(length_var_name)]
419 field_length = variable_length_array_value_template.substitute(length_var_name=length_var_name)
420 if length_field_type != 'u8': # we need net to host conversion:
421 field_length = variable_length_array_template.substitute(
422 length_field_type=length_field_type, value=field_length)
424 # for retval don't generate setters and generate retval check
425 if util.is_retval_field(c_name):
426 err_handler = callback_err_handler_template.substitute(
427 handler_name=handler_name
431 java_field_name = util.underscore_to_camelcase(c_name)
432 jni_signature = util.jni_2_signature_mapping[jni_type]
433 jni_setter = util.jni_field_accessors[jni_type]
435 dto_setters += dto_field_id_template.substitute(
436 java_name=java_field_name,
437 class_ref_name=ref_name,
438 jni_signature=jni_signature)
440 dto_setter_template = dto_field_setter_templates[c_type]
442 dto_setters += dto_setter_template.substitute(
443 java_name=java_field_name,
444 jni_signature=jni_signature,
446 jni_setter=jni_setter,
447 field_length=field_length)
449 handlers.append(msg_handler_template.substitute(
451 api_data=util.api_message_to_javadoc(f),
452 handler_name=handler_name,
454 class_ref_name=ref_name,
455 dto_setters=dto_setters,
456 err_handler=err_handler))
458 return "\n".join(handlers)
461 handler_registration_template = Template("""_(${upercase_name}, ${name}) \\
465 def generate_handler_registration(func_list):
466 handler_registration = ["#define foreach_vpe_api_msg \\\n"]
469 camelcase_name = util.underscore_to_camelcase(f['name'])
471 if (not util.is_reply(camelcase_name) and not util.is_notification(name)) or util.is_ignored(name):
474 handler_registration.append(handler_registration_template.substitute(
476 upercase_name=name.upper()))
478 return "".join(handler_registration)
481 jvpp_c_template = Template("""/**
482 * This file contains JNI bindings for jvpp Java API.
483 * It was generated by jvpp_c_gen.py based on $inputfile
484 * (python representation of vpe.api generated by vppapigen).
487 void CallOnError(const char* call, int context, int retval);
489 // JAVA class reference cache
498 // Registration of message handlers in vlib
499 $handler_registration
502 def generate_jvpp(func_list, inputfile):
503 """ Generates jvpp C file """
504 print "Generating jvpp C"
506 class_cache = generate_class_cache(func_list)
507 jni_impl = generate_jni_impl(func_list, inputfile)
508 msg_handlers = generate_msg_handlers(func_list, inputfile)
509 handler_registration = generate_handler_registration(func_list)
511 jvpp_c_file = open("jvpp_gen.h", 'w')
512 jvpp_c_file.write(jvpp_c_template.substitute(
514 class_cache=class_cache,
515 jni_implementations=jni_impl,
516 msg_handlers=msg_handlers,
517 handler_registration=handler_registration))