X-Git-Url: http://git.efficios.com/?a=blobdiff_plain;f=src%2Fbindings%2Fpython%2Fbt2%2Fbt2%2Fnative_bt_component_class.i.h;h=23e7d06a0dbcc5f1c831fa7b1bff588f490c2ef7;hb=7f3ee93db71f587960cf8c0bc12536457c413e45;hp=6844fe1a99278dcba9d8b4cdd31a22e0d665790f;hpb=5fa16feb3a91ff1f590769707e3886ddb0b4494c;p=babeltrace.git diff --git a/src/bindings/python/bt2/bt2/native_bt_component_class.i.h b/src/bindings/python/bt2/bt2/native_bt_component_class.i.h index 6844fe1a..23e7d06a 100644 --- a/src/bindings/python/bt2/bt2/native_bt_component_class.i.h +++ b/src/bindings/python/bt2/bt2/native_bt_component_class.i.h @@ -23,6 +23,7 @@ */ #include "logging/comp-logging.h" +#include "compat/glib.h" /* * This hash table associates a BT component class object address to a @@ -44,6 +45,19 @@ static GHashTable *bt_cc_ptr_to_py_cls; +static +void bt_bt2_unregister_cc_ptr_to_py_cls(const bt_component_class *comp_cls) +{ + gboolean existed; + + if (!bt_cc_ptr_to_py_cls) { + return; + } + + existed = g_hash_table_remove(bt_cc_ptr_to_py_cls, comp_cls); + BT_ASSERT(existed); +} + static void register_cc_ptr_to_py_cls(struct bt_component_class *bt_cc, PyObject *py_cls) @@ -76,72 +90,6 @@ PyObject *lookup_cc_ptr_to_py_cls(const bt_component_class *bt_cc) (gconstpointer) bt_cc); } - -/* - * Useful Python objects. - */ - -static PyObject *py_mod_bt2 = NULL; -static PyObject *py_mod_bt2_exc_error_type = NULL; -static PyObject *py_mod_bt2_exc_memory_error = NULL; -static PyObject *py_mod_bt2_exc_try_again_type = NULL; -static PyObject *py_mod_bt2_exc_stop_type = NULL; -static PyObject *py_mod_bt2_exc_unknown_object_type = NULL; - -static -void bt_bt2_cc_init_from_bt2(void) -{ - /* - * This is called once the bt2 package is loaded. - * - * Those modules and functions are needed while the package is - * used. Loading them here is safe because we know the bt2 - * package is imported, and we know that the user cannot use the - * code here without importing bt2 first. - */ - py_mod_bt2 = PyImport_ImportModule("bt2"); - BT_ASSERT(py_mod_bt2); - py_mod_bt2_exc_error_type = - PyObject_GetAttrString(py_mod_bt2, "_Error"); - BT_ASSERT(py_mod_bt2_exc_error_type); - py_mod_bt2_exc_memory_error = - PyObject_GetAttrString(py_mod_bt2, "_MemoryError"); - BT_ASSERT(py_mod_bt2_exc_memory_error); - py_mod_bt2_exc_try_again_type = - PyObject_GetAttrString(py_mod_bt2, "TryAgain"); - BT_ASSERT(py_mod_bt2_exc_try_again_type); - py_mod_bt2_exc_stop_type = - PyObject_GetAttrString(py_mod_bt2, "Stop"); - BT_ASSERT(py_mod_bt2_exc_stop_type); - py_mod_bt2_exc_unknown_object_type = - PyObject_GetAttrString(py_mod_bt2, "UnknownObject"); - BT_ASSERT(py_mod_bt2_exc_unknown_object_type); -} - -static -void bt_bt2_cc_exit_handler(void) -{ - /* - * This is an exit handler (set by the bt2 package). - * - * We only give back the references that we took in - * bt_bt2_cc_init_from_bt2() here. The global variables continue - * to exist for the code of this file, but they are now borrowed - * references. If this code is executed, it means that somehow - * the modules are still loaded, so it should be safe to use - * them even without a strong reference. - * - * We cannot do this in the library's destructor because it - * gets executed once Python is already finalized. - */ - Py_XDECREF(py_mod_bt2); - Py_XDECREF(py_mod_bt2_exc_error_type); - Py_XDECREF(py_mod_bt2_exc_try_again_type); - Py_XDECREF(py_mod_bt2_exc_stop_type); - Py_XDECREF(py_mod_bt2_exc_unknown_object_type); -} - - /* Library destructor */ __attribute__((destructor)) @@ -151,245 +99,22 @@ void native_comp_class_dtor(void) { if (bt_cc_ptr_to_py_cls) { BT_LOGD_STR("Destroying native component class to Python component class hash table."); g_hash_table_destroy(bt_cc_ptr_to_py_cls); + bt_cc_ptr_to_py_cls = NULL; } } -static -void restore_current_thread_error_and_append_exception_chain_recursive( - int active_log_level, PyObject *py_exc_value, - bt_self_component_class *self_component_class, - bt_self_component *self_component, - bt_self_message_iterator *self_message_iterator, - const char *module_name) -{ - PyObject *py_exc_cause_value; - PyObject *py_exc_type = NULL; - PyObject *py_exc_tb = NULL; - GString *gstr = NULL; - - /* If this exception has a cause, handle that one first. */ - py_exc_cause_value = PyException_GetCause(py_exc_value); - if (py_exc_cause_value) { - restore_current_thread_error_and_append_exception_chain_recursive( - active_log_level, py_exc_cause_value, - self_component_class, self_component, - self_message_iterator, module_name); - } - - /* - * If the raised exception is a bt2._Error, restore the wrapped error. - */ - if (PyErr_GivenExceptionMatches(py_exc_value, py_mod_bt2_exc_error_type)) { - PyObject *py_error_swig_ptr; - const bt_error *error; - int ret; - - /* - * We never raise a bt2._Error with a cause: it should be the - * end of the chain. - */ - BT_ASSERT(!py_exc_cause_value); - - /* - * We steal the error object from the exception, to move - * it back as the current thread's error. - */ - py_error_swig_ptr = PyObject_GetAttrString(py_exc_value, "_ptr"); - BT_ASSERT(py_error_swig_ptr); - - ret = PyObject_SetAttrString(py_exc_value, "_ptr", Py_None); - BT_ASSERT(ret == 0); - - ret = SWIG_ConvertPtr(py_error_swig_ptr, (void **) &error, - SWIGTYPE_p_bt_error, 0); - BT_ASSERT(ret == 0); - - BT_CURRENT_THREAD_MOVE_ERROR_AND_RESET(error); - - Py_DECREF(py_error_swig_ptr); - } - - py_exc_type = PyObject_Type(py_exc_value); - py_exc_tb = PyException_GetTraceback(py_exc_value); - - gstr = bt_py_common_format_exception(py_exc_type, py_exc_value, - py_exc_tb, active_log_level, false); - if (!gstr) { - /* bt_py_common_format_exception has already warned. */ - goto end; - } - - if (self_component_class) { - BT_CURRENT_THREAD_ERROR_APPEND_CAUSE_FROM_COMPONENT_CLASS( - self_component_class, "%s", gstr->str); - } else if (self_component) { - BT_CURRENT_THREAD_ERROR_APPEND_CAUSE_FROM_COMPONENT( - self_component, "%s", gstr->str); - } else if (self_message_iterator) { - BT_CURRENT_THREAD_ERROR_APPEND_CAUSE_FROM_MESSAGE_ITERATOR( - self_message_iterator, "%s", gstr->str); - } else { - BT_CURRENT_THREAD_ERROR_APPEND_CAUSE_FROM_UNKNOWN( - module_name, "%s", gstr->str); - } - -end: - if (gstr) { - g_string_free(gstr, TRUE); - } - - Py_XDECREF(py_exc_cause_value); - Py_XDECREF(py_exc_type); - Py_XDECREF(py_exc_tb); -} - -/* - * If you have the following code: - * - * try: - * try: - * something_that_raises_bt2_error() - * except bt2._Error as e1: - * raise ValueError from e1 - * except ValueError as e2: - * raise TypeError from e2 - * - * We will have the following exception chain: - * - * TypeError -> ValueError -> bt2._Error - * - * Where the TypeError is the current exception (obtained from PyErr_Fetch). - * - * The bt2._Error contains a `struct bt_error *` that used to be the current - * thread's error, at the moment the exception was raised. - * - * This function gets to the bt2._Error and restores the wrapped - * `struct bt_error *` as the current thread's error. - * - * Then, for each exception in the chain, starting with the oldest one, it adds - * an error cause to the current thread's error. - */ -static -void restore_bt_error_and_append_current_exception_chain( - int active_log_level, - bt_self_component_class *self_component_class, - bt_self_component *self_component, - bt_self_message_iterator *self_message_iterator, - const char *module_name) -{ - BT_ASSERT(PyErr_Occurred()); - - /* Used to access and restore the current exception. */ - PyObject *py_exc_type; - PyObject *py_exc_value; - PyObject *py_exc_tb; - - /* Fetch and normalize the Python exception. */ - PyErr_Fetch(&py_exc_type, &py_exc_value, &py_exc_tb); - PyErr_NormalizeException(&py_exc_type, &py_exc_value, &py_exc_tb); - BT_ASSERT(py_exc_type); - BT_ASSERT(py_exc_value); - BT_ASSERT(py_exc_tb); - - /* - * Set the exception's traceback so it's possible to get it using - * PyException_GetTraceback in - * restore_current_thread_error_and_append_exception_chain_recursive. - */ - PyException_SetTraceback(py_exc_value, py_exc_tb); - - restore_current_thread_error_and_append_exception_chain_recursive( - active_log_level, py_exc_value, self_component_class, - self_component, self_message_iterator, module_name); - - PyErr_Restore(py_exc_type, py_exc_value, py_exc_tb); -} - static inline -void log_exception_and_maybe_append_error(int func_log_level, - int active_log_level, bool append_error, +int py_exc_to_status_clear( bt_self_component_class *self_component_class, - bt_self_component *self_component, - bt_self_message_iterator *self_message_iterator, - const char *module_name) -{ - GString *gstr; - - BT_ASSERT(PyErr_Occurred()); - gstr = bt_py_common_format_current_exception(active_log_level); - if (!gstr) { - /* bt_py_common_format_current_exception() logs errors */ - goto end; - } - - BT_COMP_LOG_CUR_LVL(func_log_level, active_log_level, self_component, - "%s", gstr->str); - - if (append_error) { - restore_bt_error_and_append_current_exception_chain( - active_log_level, self_component_class, self_component, - self_message_iterator, module_name); - - } - -end: - if (gstr) { - g_string_free(gstr, TRUE); - } -} - -static -bt_logging_level get_self_component_log_level(bt_self_component *self_comp) -{ - return bt_component_get_logging_level( - bt_self_component_as_component(self_comp)); -} - -static -bt_logging_level get_self_message_iterator_log_level( - bt_self_message_iterator *self_msg_iter) -{ - bt_self_component *self_comp = - bt_self_message_iterator_borrow_component(self_msg_iter); - - return get_self_component_log_level(self_comp); -} - -static inline -void loge_exception(const char *module_name, int active_log_level) -{ - log_exception_and_maybe_append_error(BT_LOG_ERROR, active_log_level, - true, NULL, NULL, NULL, module_name); -} - -static -void loge_exception_message_iterator( - bt_self_message_iterator *self_message_iterator) -{ - bt_logging_level log_level = get_self_message_iterator_log_level( - self_message_iterator); - - log_exception_and_maybe_append_error(BT_LOG_ERROR, log_level, - true, NULL, NULL, self_message_iterator, NULL); -} - -static inline -void logw_exception(int active_log_level) -{ - log_exception_and_maybe_append_error(BT_LOG_WARNING, active_log_level, - false, NULL, NULL, NULL, NULL); -} - -static inline -int py_exc_to_status(bt_self_component_class *self_component_class, bt_self_component *self_component, bt_self_message_iterator *self_message_iterator, const char *module_name, int active_log_level) { - int status = __BT_FUNC_STATUS_OK; + int status; PyObject *exc = PyErr_Occurred(); if (!exc) { + status = __BT_FUNC_STATUS_OK; goto end; } @@ -421,7 +146,7 @@ int py_exc_to_status(bt_self_component_class *self_component_class, } BT_ASSERT(active_log_level != -1); - log_exception_and_maybe_append_error(BT_LOG_WARNING, + log_exception_and_maybe_append_cause(BT_LOG_WARNING, active_log_level, true, self_component_class, self_component, self_message_iterator, module_name); @@ -440,31 +165,37 @@ end: } static -int py_exc_to_status_component_class( +int py_exc_to_status_component_class_clear( bt_self_component_class *self_component_class, int active_log_level) { - return py_exc_to_status(self_component_class, NULL, NULL, NULL, + return py_exc_to_status_clear(self_component_class, NULL, NULL, NULL, active_log_level); } static -int py_exc_to_status_component(bt_self_component *self_component) +int py_exc_to_status_component_clear(bt_self_component *self_component) { - return py_exc_to_status(NULL, self_component, NULL, NULL, -1); + return py_exc_to_status_clear(NULL, self_component, NULL, NULL, -1); } static -int py_exc_to_status_message_iterator( +int py_exc_to_status_message_iterator_clear( bt_self_message_iterator *self_message_iterator) { - return py_exc_to_status(NULL, NULL, self_message_iterator, NULL, -1); + return py_exc_to_status_clear(NULL, NULL, self_message_iterator, NULL, -1); +} + +static +bool bt_bt2_is_python_component_class(const bt_component_class *comp_cls) +{ + return bt_g_hash_table_contains(bt_cc_ptr_to_py_cls, comp_cls); } /* Component class proxy methods (delegate to the attached Python object) */ static -bt_component_class_init_method_status component_class_init( +bt_component_class_initialize_method_status component_class_init( bt_self_component *self_component, void *self_component_v, swig_type_info *self_comp_cls_type_swig_type, @@ -473,7 +204,7 @@ bt_component_class_init_method_status component_class_init( { const bt_component *component = bt_self_component_as_component(self_component); const bt_component_class *component_class = bt_component_borrow_class_const(component); - bt_component_class_init_method_status status = __BT_FUNC_STATUS_OK; + bt_component_class_initialize_method_status status; PyObject *py_cls = NULL; PyObject *py_comp = NULL; PyObject *py_params_ptr = NULL; @@ -481,8 +212,6 @@ bt_component_class_init_method_status component_class_init( bt_logging_level log_level = get_self_component_log_level( self_component); - (void) init_method_data; - BT_ASSERT(self_component); BT_ASSERT(self_component_v); BT_ASSERT(self_comp_cls_type_swig_type); @@ -520,18 +249,26 @@ bt_component_class_init_method_status component_class_init( /* * Do the equivalent of this: * - * py_comp = py_cls._bt_init_from_native(py_comp_ptr, py_params_ptr) + * py_comp = py_cls._bt_init_from_native(py_comp_ptr, + * py_params_ptr, init_method_data ? init_method_data : Py_None) * * _UserComponentType._bt_init_from_native() calls the Python * component object's __init__() function. + * + * We don't take any reference on `init_method_data` which, if + * not `NULL`, is assumed to be a `PyObject *`: the user's + * __init__() function will eventually take a reference if + * needed. If `init_method_data` is `NULL`, then we pass + * `Py_None` as the initialization's Python object. */ py_comp = PyObject_CallMethod(py_cls, - "_bt_init_from_native", "(OO)", py_comp_ptr, py_params_ptr); + "_bt_init_from_native", "(OOO)", py_comp_ptr, py_params_ptr, + init_method_data ? init_method_data : Py_None); if (!py_comp) { BT_COMP_LOG_CUR_LVL(BT_LOG_WARNING, log_level, self_component, "Failed to call Python class's _bt_init_from_native() method: " "py-cls-addr=%p", py_cls); - status = py_exc_to_status_component(self_component); + status = py_exc_to_status_component_clear(self_component); goto end; } @@ -542,34 +279,180 @@ bt_component_class_init_method_status component_class_init( */ bt_self_component_set_data(self_component, py_comp); py_comp = NULL; + + status = BT_COMPONENT_CLASS_INITIALIZE_METHOD_STATUS_OK; + goto end; error: - status = __BT_FUNC_STATUS_ERROR; + /* This error path is for non-Python errors only. */ + status = BT_COMPONENT_CLASS_INITIALIZE_METHOD_STATUS_ERROR; + +end: + BT_ASSERT(!PyErr_Occurred()); + Py_XDECREF(py_comp); + Py_XDECREF(py_params_ptr); + Py_XDECREF(py_comp_ptr); + return status; +} + +static +bt_component_class_get_supported_mip_versions_method_status +component_class_get_supported_mip_versions( + const bt_component_class *component_class, + bt_self_component_class *self_component_class, + const bt_value *params, void *init_method_data, + bt_logging_level log_level, + bt_integer_range_set_unsigned *supported_versions) +{ + uint64_t i; + PyObject *py_cls = NULL; + PyObject *py_params_ptr = NULL; + PyObject *py_range_set_addr = NULL; + bt_integer_range_set_unsigned *ret_range_set = NULL; + bt_component_class_get_supported_mip_versions_method_status status; + + py_cls = lookup_cc_ptr_to_py_cls(component_class); + if (!py_cls) { + BT_LOG_WRITE_CUR_LVL(BT_LOG_ERROR, log_level, BT_LOG_TAG, + "Cannot find Python class associated to native component class: " + "comp-cls-addr=%p", component_class); + goto error; + } + + py_params_ptr = SWIG_NewPointerObj(SWIG_as_voidptr(params), + SWIGTYPE_p_bt_value, 0); + if (!py_params_ptr) { + BT_LOG_WRITE_CUR_LVL(BT_LOG_ERROR, log_level, BT_LOG_TAG, + "Failed to create a SWIG pointer object."); + goto error; + } /* - * Clear any exception: we're returning a bad status anyway. If - * this call originated from Python (creation from a plugin's - * component class, for example), then the user gets an - * appropriate creation error. + * We don't take any reference on `init_method_data` which, if + * not `NULL`, is assumed to be a `PyObject *`: the user's + * _user_get_supported_mip_versions() function will eventually + * take a reference if needed. If `init_method_data` is `NULL`, + * then we pass `Py_None` as the initialization's Python object. */ - PyErr_Clear(); + py_range_set_addr = PyObject_CallMethod(py_cls, + "_bt_get_supported_mip_versions_from_native", "(OOi)", + py_params_ptr, init_method_data ? init_method_data : Py_None, + (int) log_level); + if (!py_range_set_addr) { + BT_LOG_WRITE_CUR_LVL(BT_LOG_WARNING, log_level, BT_LOG_TAG, + "Failed to call Python class's _bt_get_supported_mip_versions_from_native() method: " + "py-cls-addr=%p", py_cls); + status = py_exc_to_status_component_class_clear(self_component_class, + log_level); + goto end; + } + + /* + * The returned object, on success, is an integer object + * (PyLong) containing the address of a BT unsigned integer + * range set object (new reference). + */ + ret_range_set = PyLong_AsVoidPtr(py_range_set_addr); + BT_ASSERT(!PyErr_Occurred()); + BT_ASSERT(ret_range_set); + + /* Copy returned ranges to input range set */ + for (i = 0; i < bt_integer_range_set_get_range_count( + bt_integer_range_set_unsigned_as_range_set_const(ret_range_set)); + i++) { + const bt_integer_range_unsigned *range = + bt_integer_range_set_unsigned_borrow_range_by_index_const( + ret_range_set, i); + bt_integer_range_set_add_range_status add_range_status; + + add_range_status = bt_integer_range_set_unsigned_add_range( + supported_versions, + bt_integer_range_unsigned_get_lower(range), + bt_integer_range_unsigned_get_upper(range)); + if (add_range_status) { + BT_LOG_WRITE_CUR_LVL(BT_LOG_ERROR, log_level, BT_LOG_TAG, + "Failed to add range to supported MIP versions range set."); + goto error; + } + } + + status = BT_COMPONENT_CLASS_GET_SUPPORTED_MIP_VERSIONS_METHOD_STATUS_OK; + + goto end; + +error: + /* This error path is for non-Python errors only. */ + status = BT_COMPONENT_CLASS_GET_SUPPORTED_MIP_VERSIONS_METHOD_STATUS_ERROR; end: - Py_XDECREF(py_comp); + BT_ASSERT(!PyErr_Occurred()); Py_XDECREF(py_params_ptr); - Py_XDECREF(py_comp_ptr); + Py_XDECREF(py_range_set_addr); + bt_integer_range_set_unsigned_put_ref(ret_range_set); return status; } +static +bt_component_class_get_supported_mip_versions_method_status +component_class_source_get_supported_mip_versions( + bt_self_component_class_source *self_component_class_source, + const bt_value *params, void *init_method_data, + bt_logging_level log_level, + bt_integer_range_set_unsigned *supported_versions) +{ + const bt_component_class_source *component_class_source = bt_self_component_class_source_as_component_class_source(self_component_class_source); + const bt_component_class *component_class = bt_component_class_source_as_component_class_const(component_class_source); + bt_self_component_class *self_component_class = bt_self_component_class_source_as_self_component_class(self_component_class_source); + + return component_class_get_supported_mip_versions( + component_class, self_component_class, + params, init_method_data, log_level, supported_versions); +} + +static +bt_component_class_get_supported_mip_versions_method_status +component_class_filter_get_supported_mip_versions( + bt_self_component_class_filter *self_component_class_filter, + const bt_value *params, void *init_method_data, + bt_logging_level log_level, + bt_integer_range_set_unsigned *supported_versions) +{ + const bt_component_class_filter *component_class_filter = bt_self_component_class_filter_as_component_class_filter(self_component_class_filter); + const bt_component_class *component_class = bt_component_class_filter_as_component_class_const(component_class_filter); + bt_self_component_class *self_component_class = bt_self_component_class_filter_as_self_component_class(self_component_class_filter); + + return component_class_get_supported_mip_versions( + component_class, self_component_class, + params, init_method_data, log_level, supported_versions); +} + +static +bt_component_class_get_supported_mip_versions_method_status +component_class_sink_get_supported_mip_versions( + bt_self_component_class_sink *self_component_class_sink, + const bt_value *params, void *init_method_data, + bt_logging_level log_level, + bt_integer_range_set_unsigned *supported_versions) +{ + const bt_component_class_sink *component_class_sink = bt_self_component_class_sink_as_component_class_sink(self_component_class_sink); + const bt_component_class *component_class = bt_component_class_sink_as_component_class_const(component_class_sink); + bt_self_component_class *self_component_class = bt_self_component_class_sink_as_self_component_class(self_component_class_sink); + + return component_class_get_supported_mip_versions( + component_class, self_component_class, + params, init_method_data, log_level, supported_versions); +} + /* * Method of bt_component_class_source to initialize a bt_self_component_source * of that class. */ static -bt_component_class_init_method_status component_class_source_init( +bt_component_class_initialize_method_status component_class_source_init( bt_self_component_source *self_component_source, + bt_self_component_source_configuration *config, const bt_value *params, void *init_method_data) { bt_self_component *self_component = bt_self_component_source_as_self_component(self_component_source); @@ -581,8 +464,9 @@ bt_component_class_init_method_status component_class_source_init( } static -bt_component_class_init_method_status component_class_filter_init( +bt_component_class_initialize_method_status component_class_filter_init( bt_self_component_filter *self_component_filter, + bt_self_component_filter_configuration *config, const bt_value *params, void *init_method_data) { bt_self_component *self_component = bt_self_component_filter_as_self_component(self_component_filter); @@ -594,8 +478,9 @@ bt_component_class_init_method_status component_class_filter_init( } static -bt_component_class_init_method_status component_class_sink_init( +bt_component_class_initialize_method_status component_class_sink_init( bt_self_component_sink *self_component_sink, + bt_self_component_sink_configuration *config, const bt_value *params, void *init_method_data) { bt_self_component *self_component = bt_self_component_sink_as_self_component(self_component_sink); @@ -610,27 +495,32 @@ static void component_class_finalize(bt_self_component *self_component) { PyObject *py_comp = bt_self_component_get_data(self_component); + PyObject *py_method_result; + BT_ASSERT(py_comp); /* Call user's _user_finalize() method */ - PyObject *py_method_result = PyObject_CallMethod(py_comp, - "_user_finalize", NULL); - - if (PyErr_Occurred()) { + py_method_result = PyObject_CallMethod(py_comp, "_user_finalize", NULL); + if (!py_method_result) { bt_logging_level log_level = get_self_component_log_level( self_component); BT_COMP_LOG_CUR_LVL(BT_LOG_WARNING, log_level, self_component, "User component's _user_finalize() method raised an exception: ignoring:"); logw_exception(log_level); + + /* + * Ignore any exception raised by the _user_finalize() method + * because it won't change anything at this point: the component + * is being destroyed anyway. + */ + PyErr_Clear(); + goto end; } - /* - * Ignore any exception raised by the _user_finalize() method - * because it won't change anything at this point: the component - * is being destroyed anyway. - */ - PyErr_Clear(); + BT_ASSERT(py_method_result == Py_None); + +end: Py_XDECREF(py_method_result); Py_DECREF(py_comp); } @@ -657,34 +547,33 @@ void component_class_sink_finalize(bt_self_component_sink *self_component_sink) } static -bt_bool component_class_can_seek_beginning( - bt_self_message_iterator *self_message_iterator) +bt_component_class_message_iterator_can_seek_beginning_method_status +component_class_can_seek_beginning( + bt_self_message_iterator *self_message_iterator, bt_bool *can_seek) { PyObject *py_iter; PyObject *py_result = NULL; - bt_bool can_seek_beginning = false; - + bt_component_class_message_iterator_can_seek_beginning_method_status status; py_iter = bt_self_message_iterator_get_data(self_message_iterator); + BT_ASSERT(py_iter); - py_result = PyObject_GetAttrString(py_iter, "_bt_can_seek_beginning_from_native"); + py_result = PyObject_CallMethod(py_iter, + "_bt_can_seek_beginning_from_native", NULL); + if (!py_result) { + status = py_exc_to_status_message_iterator_clear(self_message_iterator); + goto end; + } - BT_ASSERT(!py_result || PyBool_Check(py_result)); + BT_ASSERT(PyBool_Check(py_result)); + *can_seek = PyObject_IsTrue(py_result); - if (py_result) { - can_seek_beginning = PyObject_IsTrue(py_result); - } else { - /* - * Once can_seek_beginning can report errors, convert the - * exception to a status. For now, log and return false; - */ - loge_exception_message_iterator(self_message_iterator); - PyErr_Clear(); - } + status = BT_COMPONENT_CLASS_MESSAGE_ITERATOR_CAN_SEEK_BEGINNING_METHOD_STATUS_OK; +end: Py_XDECREF(py_result); - return can_seek_beginning; + return status; } static @@ -697,11 +586,84 @@ component_class_seek_beginning(bt_self_message_iterator *self_message_iterator) py_iter = bt_self_message_iterator_get_data(self_message_iterator); BT_ASSERT(py_iter); - py_result = PyObject_CallMethod(py_iter, "_bt_seek_beginning_from_native", + + py_result = PyObject_CallMethod(py_iter, + "_bt_seek_beginning_from_native", NULL); - BT_ASSERT(!py_result || py_result == Py_None); - status = py_exc_to_status_message_iterator(self_message_iterator); + if (!py_result) { + status = py_exc_to_status_message_iterator_clear(self_message_iterator); + goto end; + } + + BT_ASSERT(py_result == Py_None); + + status = BT_COMPONENT_CLASS_MESSAGE_ITERATOR_SEEK_BEGINNING_METHOD_STATUS_OK; + +end: + Py_XDECREF(py_result); + + return status; +} + +static +bt_component_class_message_iterator_can_seek_ns_from_origin_method_status +component_class_can_seek_ns_from_origin( + bt_self_message_iterator *self_message_iterator, + int64_t ns_from_origin, bt_bool *can_seek) +{ + PyObject *py_iter; + PyObject *py_result = NULL; + bt_component_class_message_iterator_can_seek_ns_from_origin_method_status status; + + py_iter = bt_self_message_iterator_get_data(self_message_iterator); + BT_ASSERT(py_iter); + + py_result = PyObject_CallMethod(py_iter, + "_bt_can_seek_ns_from_origin_from_native", "L", ns_from_origin); + if (!py_result) { + status = py_exc_to_status_message_iterator_clear(self_message_iterator); + goto end; + } + + BT_ASSERT(PyBool_Check(py_result)); + *can_seek = PyObject_IsTrue(py_result); + + status = BT_COMPONENT_CLASS_MESSAGE_ITERATOR_CAN_SEEK_NS_FROM_ORIGIN_METHOD_STATUS_OK; + +end: + Py_XDECREF(py_result); + + return status; +} + +static +bt_component_class_message_iterator_seek_ns_from_origin_method_status +component_class_seek_ns_from_origin( + bt_self_message_iterator *self_message_iterator, + int64_t ns_from_origin) +{ + PyObject *py_iter; + PyObject *py_result; + bt_component_class_message_iterator_seek_ns_from_origin_method_status status; + + py_iter = bt_self_message_iterator_get_data(self_message_iterator); + BT_ASSERT(py_iter); + + py_result = PyObject_CallMethod(py_iter, + "_bt_seek_ns_from_origin_from_native", "L", ns_from_origin); + if (!py_result) { + status = py_exc_to_status_message_iterator_clear(self_message_iterator); + goto end; + } + + + BT_ASSERT(py_result == Py_None); + + status = BT_COMPONENT_CLASS_MESSAGE_ITERATOR_SEEK_NS_FROM_ORIGIN_METHOD_STATUS_OK; + +end: Py_XDECREF(py_result); + return status; } @@ -739,18 +701,26 @@ bt_component_class_port_connected_method_status component_class_port_connected( BT_COMP_LOG_CUR_LVL(BT_LOG_ERROR, log_level, self_component, "Failed to create a SWIG pointer object."); status = __BT_FUNC_STATUS_MEMORY_ERROR; - goto end; } + goto end; + } py_method_result = PyObject_CallMethod(py_comp, "_bt_port_connected_from_native", "(OiO)", py_self_port_ptr, self_component_port_type, py_other_port_ptr); - BT_ASSERT(!py_method_result || py_method_result == Py_None); - status = py_exc_to_status_component(self_component); + if (!py_method_result) { + status = py_exc_to_status_component_clear(self_component); + goto end; + } + + BT_ASSERT(py_method_result == Py_None); + + status = BT_COMPONENT_CLASS_PORT_CONNECTED_METHOD_STATUS_OK; end: Py_XDECREF(py_self_port_ptr); Py_XDECREF(py_other_port_ptr); Py_XDECREF(py_method_result); + return status; } @@ -833,14 +803,23 @@ component_class_sink_graph_is_configured( { PyObject *py_comp = NULL; PyObject *py_method_result = NULL; - bt_component_class_sink_graph_is_configured_method_status status = __BT_FUNC_STATUS_OK; + bt_component_class_sink_graph_is_configured_method_status status; bt_self_component *self_component = bt_self_component_sink_as_self_component(self_component_sink); py_comp = bt_self_component_get_data(self_component); + py_method_result = PyObject_CallMethod(py_comp, "_bt_graph_is_configured_from_native", NULL); - BT_ASSERT(!py_method_result || py_method_result == Py_None); - status = py_exc_to_status_component(self_component); + if (!py_method_result) { + status = py_exc_to_status_component_clear(self_component); + goto end; + } + + BT_ASSERT(py_method_result == Py_None); + + status = BT_COMPONENT_CLASS_SINK_GRAPH_IS_CONFIGURED_METHOD_STATUS_OK;; + +end: Py_XDECREF(py_method_result); return status; } @@ -850,7 +829,7 @@ bt_component_class_query_method_status component_class_query( const bt_component_class *component_class, bt_self_component_class *self_component_class, bt_private_query_executor *priv_query_executor, - const char *object, const bt_value *params, + const char *object, const bt_value *params, void *method_data, const bt_value **result) { PyObject *py_cls = NULL; @@ -866,6 +845,14 @@ bt_component_class_query_method_status component_class_query( bt_logging_level log_level = bt_query_executor_get_logging_level(query_exec); + /* + * If there's any `method_data`, assume this component class is + * getting queried from Python, so that `method_data` is a + * Python object to pass to the user's _user_query() method. + */ + BT_ASSERT(!method_data || + bt_bt2_is_python_component_class(component_class)); + py_cls = lookup_cc_ptr_to_py_cls(component_class); if (!py_cls) { BT_LOG_WRITE_CUR_LVL(BT_LOG_ERROR, log_level, BT_LOG_TAG, @@ -898,15 +885,28 @@ bt_component_class_query_method_status component_class_query( goto error; } + /* + * We don't take any reference on `method_data` which, if not + * `NULL`, is assumed to be a `PyObject *`: the user's + * _user_query() function will eventually take a reference if + * needed. If `method_data` is `NULL`, then we pass `Py_None` as + * the initialization's Python object. + */ py_results_addr = PyObject_CallMethod(py_cls, - "_bt_query_from_native", "(OOO)", py_priv_query_exec_ptr, - py_object, py_params_ptr); + "_bt_query_from_native", "(OOOO)", py_priv_query_exec_ptr, + py_object, py_params_ptr, + method_data ? method_data : Py_None); if (!py_results_addr) { - BT_LOG_WRITE_CUR_LVL(BT_LOG_WARNING, log_level, BT_LOG_TAG, - "Failed to call Python class's _bt_query_from_native() method: " - "py-cls-addr=%p", py_cls); - status = py_exc_to_status_component_class(self_component_class, + status = py_exc_to_status_component_class_clear(self_component_class, log_level); + if (status < 0) { + static const char *fmt = + "Failed to call Python class's _bt_query_from_native() method: py-cls-addr=%p"; + BT_LOG_WRITE_CUR_LVL(BT_LOG_WARNING, log_level, BT_LOG_TAG, + fmt, py_cls); + BT_CURRENT_THREAD_ERROR_APPEND_CAUSE_FROM_COMPONENT_CLASS( + self_component_class, fmt, py_cls); + } goto end; } @@ -937,7 +937,7 @@ static bt_component_class_query_method_status component_class_source_query( bt_self_component_class_source *self_component_class_source, bt_private_query_executor *priv_query_executor, - const char *object, const bt_value *params, + const char *object, const bt_value *params, void *method_data, const bt_value **result) { const bt_component_class_source *component_class_source = bt_self_component_class_source_as_component_class_source(self_component_class_source); @@ -945,14 +945,14 @@ bt_component_class_query_method_status component_class_source_query( bt_self_component_class *self_component_class = bt_self_component_class_source_as_self_component_class(self_component_class_source); return component_class_query(component_class, self_component_class, - priv_query_executor, object, params, result); + priv_query_executor, object, params, method_data, result); } static bt_component_class_query_method_status component_class_filter_query( bt_self_component_class_filter *self_component_class_filter, bt_private_query_executor *priv_query_executor, - const char *object, const bt_value *params, + const char *object, const bt_value *params, void *method_data, const bt_value **result) { const bt_component_class_filter *component_class_filter = bt_self_component_class_filter_as_component_class_filter(self_component_class_filter); @@ -960,14 +960,14 @@ bt_component_class_query_method_status component_class_filter_query( bt_self_component_class *self_component_class = bt_self_component_class_filter_as_self_component_class(self_component_class_filter); return component_class_query(component_class, self_component_class, - priv_query_executor, object, params, result); + priv_query_executor, object, params, method_data, result); } static bt_component_class_query_method_status component_class_sink_query( bt_self_component_class_sink *self_component_class_sink, bt_private_query_executor *priv_query_executor, - const char *object, const bt_value *params, + const char *object, const bt_value *params, void *method_data, const bt_value **result) { const bt_component_class_sink *component_class_sink = bt_self_component_class_sink_as_component_class_sink(self_component_class_sink); @@ -975,20 +975,22 @@ bt_component_class_query_method_status component_class_sink_query( bt_self_component_class *self_component_class = bt_self_component_class_sink_as_self_component_class(self_component_class_sink); return component_class_query(component_class, self_component_class, - priv_query_executor, object, params, result); + priv_query_executor, object, params, method_data, result); } static -bt_component_class_message_iterator_init_method_status +bt_component_class_message_iterator_initialize_method_status component_class_message_iterator_init( bt_self_message_iterator *self_message_iterator, + bt_self_message_iterator_configuration *config, bt_self_component *self_component, bt_self_component_port_output *self_component_port_output) { - bt_component_class_message_iterator_init_method_status status = __BT_FUNC_STATUS_OK; + bt_component_class_message_iterator_initialize_method_status status = __BT_FUNC_STATUS_OK; PyObject *py_comp_cls = NULL; PyObject *py_iter_cls = NULL; PyObject *py_iter_ptr = NULL; + PyObject *py_config_ptr = NULL; PyObject *py_component_port_output_ptr = NULL; PyObject *py_init_method_result = NULL; PyObject *py_iter = NULL; @@ -1043,15 +1045,27 @@ component_class_message_iterator_init( /* * Initialize object: * - * py_iter.__init__(self_output_port) + * py_iter.__init__(config, self_output_port) * - * through the _init_for_native helper static method. + * through the _init_from_native helper static method. * * At this point, py_iter._ptr is set, so this initialization * function has access to self._component (which gives it the * user Python component object from which the iterator was * created). */ + py_config_ptr = SWIG_NewPointerObj(SWIG_as_voidptr(config), + SWIGTYPE_p_bt_self_message_iterator_configuration, 0); + if (!py_config_ptr) { + const char *err = "Failed to create a SWIG pointer object"; + + BT_COMP_LOG_CUR_LVL(BT_LOG_ERROR, log_level, self_component, + "%s", err); + BT_CURRENT_THREAD_ERROR_APPEND_CAUSE_FROM_MESSAGE_ITERATOR( + self_message_iterator, err); + goto error; + } + py_component_port_output_ptr = SWIG_NewPointerObj( SWIG_as_voidptr(self_component_port_output), SWIGTYPE_p_bt_self_component_port_output, 0); @@ -1066,7 +1080,8 @@ component_class_message_iterator_init( } py_init_method_result = PyObject_CallMethod(py_iter, - "_bt_init_from_native", "O", py_component_port_output_ptr); + "_bt_init_from_native", "OO", py_config_ptr, + py_component_port_output_ptr); if (!py_init_method_result) { BT_COMP_LOG_CUR_LVL(BT_LOG_ERROR, log_level, self_component, "User's __init__() method failed:"); @@ -1097,8 +1112,7 @@ component_class_message_iterator_init( python_error: /* Handling of errors that cause a Python exception to be set. */ - status = py_exc_to_status_message_iterator(self_message_iterator); - BT_ASSERT(status != __BT_FUNC_STATUS_OK); + status = py_exc_to_status_message_iterator_clear(self_message_iterator); goto end; error: @@ -1118,27 +1132,33 @@ end: } static -bt_component_class_message_iterator_init_method_status +bt_component_class_message_iterator_initialize_method_status component_class_source_message_iterator_init( bt_self_message_iterator *self_message_iterator, + bt_self_message_iterator_configuration *config, bt_self_component_source *self_component_source, bt_self_component_port_output *self_component_port_output) { - bt_self_component *self_component = bt_self_component_source_as_self_component(self_component_source); + bt_self_component *self_component = + bt_self_component_source_as_self_component(self_component_source); - return component_class_message_iterator_init(self_message_iterator, self_component, self_component_port_output); + return component_class_message_iterator_init(self_message_iterator, + config, self_component, self_component_port_output); } static -bt_component_class_message_iterator_init_method_status +bt_component_class_message_iterator_initialize_method_status component_class_filter_message_iterator_init( bt_self_message_iterator *self_message_iterator, + bt_self_message_iterator_configuration *config, bt_self_component_filter *self_component_filter, bt_self_component_port_output *self_component_port_output) { - bt_self_component *self_component = bt_self_component_filter_as_self_component(self_component_filter); + bt_self_component *self_component = + bt_self_component_filter_as_self_component(self_component_filter); - return component_class_message_iterator_init(self_message_iterator, self_component, self_component_port_output); + return component_class_message_iterator_init(self_message_iterator, + config, self_component, self_component_port_output); } static @@ -1154,8 +1174,7 @@ void component_class_message_iterator_finalize( /* Call user's _user_finalize() method */ py_method_result = PyObject_CallMethod(py_message_iter, "_user_finalize", NULL); - - if (PyErr_Occurred()) { + if (!py_method_result) { bt_self_component *self_comp = bt_self_message_iterator_borrow_component( message_iterator); @@ -1166,14 +1185,15 @@ void component_class_message_iterator_finalize( "User's _user_finalize() method raised an exception: ignoring:"); logw_exception(get_self_message_iterator_log_level( message_iterator)); + + /* + * Ignore any exception raised by the _user_finalize() method + * because it won't change anything at this point: the component + * is being destroyed anyway. + */ + PyErr_Clear(); } - /* - * Ignore any exception raised by the _user_finalize() method - * because it won't change anything at this point: the component - * is being destroyed anyway. - */ - PyErr_Clear(); Py_XDECREF(py_method_result); Py_DECREF(py_message_iter); } @@ -1187,16 +1207,16 @@ component_class_message_iterator_next( bt_message_array_const msgs, uint64_t capacity, uint64_t *count) { - bt_component_class_message_iterator_next_method_status status = __BT_FUNC_STATUS_OK; + bt_component_class_message_iterator_next_method_status status; PyObject *py_message_iter = bt_self_message_iterator_get_data(message_iterator); PyObject *py_method_result = NULL; BT_ASSERT(py_message_iter); + py_method_result = PyObject_CallMethod(py_message_iter, "_bt_next_from_native", NULL); if (!py_method_result) { - status = py_exc_to_status_message_iterator(message_iterator); - BT_ASSERT(status != __BT_FUNC_STATUS_OK); + status = py_exc_to_status_message_iterator_clear(message_iterator); goto end; } @@ -1208,9 +1228,10 @@ component_class_message_iterator_next( msgs[0] = PyLong_AsVoidPtr(py_method_result); *count = 1; - /* Clear potential overflow error; should never happen */ + /* Overflow errors should never happen. */ BT_ASSERT(!PyErr_Occurred()); - goto end; + + status = BT_COMPONENT_CLASS_MESSAGE_ITERATOR_NEXT_METHOD_STATUS_OK; end: Py_XDECREF(py_method_result); @@ -1227,10 +1248,17 @@ component_class_sink_consume(bt_self_component_sink *self_component_sink) bt_component_class_sink_consume_method_status status; BT_ASSERT(py_comp); + py_method_result = PyObject_CallMethod(py_comp, "_user_consume", NULL); - status = py_exc_to_status_component(self_component); - BT_ASSERT(py_method_result || status != __BT_FUNC_STATUS_OK); + if (!py_method_result) { + status = py_exc_to_status_component_clear(self_component); + goto end; + } + + status = BT_COMPONENT_CLASS_SINK_CONSUME_METHOD_STATUS_OK; + +end: Py_XDECREF(py_method_result); return status; } @@ -1289,22 +1317,24 @@ bt_component_class_source *bt_bt2_component_class_source_create( goto end; } - ret = bt_component_class_source_set_init_method(component_class_source, component_class_source_init); + ret = bt_component_class_source_set_initialize_method(component_class_source, component_class_source_init); BT_ASSERT(ret == 0); ret = bt_component_class_source_set_finalize_method(component_class_source, component_class_source_finalize); BT_ASSERT(ret == 0); - ret = bt_component_class_source_set_message_iterator_can_seek_beginning_method(component_class_source, - component_class_can_seek_beginning); - BT_ASSERT(ret == 0); - ret = bt_component_class_source_set_message_iterator_seek_beginning_method(component_class_source, - component_class_seek_beginning); + ret = bt_component_class_source_set_message_iterator_seek_beginning_methods(component_class_source, + component_class_seek_beginning, component_class_can_seek_beginning); + ret = bt_component_class_source_set_message_iterator_seek_ns_from_origin_methods( + component_class_source, component_class_seek_ns_from_origin, + component_class_can_seek_ns_from_origin); BT_ASSERT(ret == 0); ret = bt_component_class_source_set_output_port_connected_method(component_class_source, component_class_source_output_port_connected); BT_ASSERT(ret == 0); ret = bt_component_class_source_set_query_method(component_class_source, component_class_source_query); BT_ASSERT(ret == 0); - ret = bt_component_class_source_set_message_iterator_init_method( + ret = bt_component_class_source_set_get_supported_mip_versions_method(component_class_source, component_class_source_get_supported_mip_versions); + BT_ASSERT(ret == 0); + ret = bt_component_class_source_set_message_iterator_initialize_method( component_class_source, component_class_source_message_iterator_init); BT_ASSERT(ret == 0); ret = bt_component_class_source_set_message_iterator_finalize_method( @@ -1339,16 +1369,16 @@ bt_component_class_filter *bt_bt2_component_class_filter_create( goto end; } - ret = bt_component_class_filter_set_init_method(component_class_filter, component_class_filter_init); + ret = bt_component_class_filter_set_initialize_method(component_class_filter, component_class_filter_init); BT_ASSERT(ret == 0); ret = bt_component_class_filter_set_finalize_method (component_class_filter, component_class_filter_finalize); BT_ASSERT(ret == 0); - ret = bt_component_class_filter_set_message_iterator_can_seek_beginning_method(component_class_filter, - component_class_can_seek_beginning); - BT_ASSERT(ret == 0); - ret = bt_component_class_filter_set_message_iterator_seek_beginning_method(component_class_filter, - component_class_seek_beginning); + ret = bt_component_class_filter_set_message_iterator_seek_beginning_methods(component_class_filter, + component_class_seek_beginning, component_class_can_seek_beginning); BT_ASSERT(ret == 0); + ret = bt_component_class_filter_set_message_iterator_seek_ns_from_origin_methods( + component_class_filter, component_class_seek_ns_from_origin, + component_class_can_seek_ns_from_origin); ret = bt_component_class_filter_set_input_port_connected_method(component_class_filter, component_class_filter_input_port_connected); BT_ASSERT(ret == 0); @@ -1357,7 +1387,9 @@ bt_component_class_filter *bt_bt2_component_class_filter_create( BT_ASSERT(ret == 0); ret = bt_component_class_filter_set_query_method(component_class_filter, component_class_filter_query); BT_ASSERT(ret == 0); - ret = bt_component_class_filter_set_message_iterator_init_method( + ret = bt_component_class_filter_set_get_supported_mip_versions_method(component_class_filter, component_class_filter_get_supported_mip_versions); + BT_ASSERT(ret == 0); + ret = bt_component_class_filter_set_message_iterator_initialize_method( component_class_filter, component_class_filter_message_iterator_init); BT_ASSERT(ret == 0); ret = bt_component_class_filter_set_message_iterator_finalize_method( @@ -1392,7 +1424,7 @@ bt_component_class_sink *bt_bt2_component_class_sink_create( goto end; } - ret = bt_component_class_sink_set_init_method(component_class_sink, component_class_sink_init); + ret = bt_component_class_sink_set_initialize_method(component_class_sink, component_class_sink_init); BT_ASSERT(ret == 0); ret = bt_component_class_sink_set_finalize_method(component_class_sink, component_class_sink_finalize); BT_ASSERT(ret == 0); @@ -1404,6 +1436,8 @@ bt_component_class_sink *bt_bt2_component_class_sink_create( BT_ASSERT(ret == 0); ret = bt_component_class_sink_set_query_method(component_class_sink, component_class_sink_query); BT_ASSERT(ret == 0); + ret = bt_component_class_sink_set_get_supported_mip_versions_method(component_class_sink, component_class_sink_get_supported_mip_versions); + BT_ASSERT(ret == 0); register_cc_ptr_to_py_cls(component_class, py_cls); end: