Add facilities to ease usage of async native patterns like boost::asio

I have been using 2 patterns of code to use native code in a promised way with completion handlers from native code, which iof course usually have their own thread regime and don't want to use worker threads from node. Specifically I am using boost::asio oriented code with own managed threads.

See https://github.com/Superlokkus/node-addon-api/blob/master/doc/generic_callback_wrapper.md for documentation and example

I have put my first pattern for simple "Get value from native function which calls a completion handler to a promise" into a class GenericCallbackWrapper and added unit tests. See my PR in a couple of seconds, I guess you want some changes or discussion since for now I hoped to be able to use Node >=10, but I can change that.

BTW here are the wrappers you could also use stand alone without PR:

#include <napi.h>
#include <functional>
#include <future>
#include <memory>
#include <utility>

#include <stdexcept>

template<typename T>
class generic_callback_wrapper {
public:
    using result_t [[maybe_unused]] = T;
    using callback_t = std::function<void(std::future<T>)>;
    using conversion_function_t = std::function<Napi::Value(const Napi::Env &, std::future<T> &&)>;

    generic_callback_wrapper(const Napi::Promise::Deferred &deferred, conversion_function_t conversion_function)
            : internal_(std::make_shared<internal>(deferred, conversion_function)) {
        internal_->set_up();
    }

    /*!
     * @brief The native callback shall only be called once per wrapper
     * @return
     */
    callback_t get_native_callback() {
        return internal_->get_native_callback();
    }

private:
    struct internal : std::enable_shared_from_this<internal> {
        Napi::Promise::Deferred deferred_;
        Napi::ThreadSafeFunction function_;
        std::future<T> result_;
        conversion_function_t conversion_function_;

        internal(const Napi::Promise::Deferred &deferred,
                 conversion_function_t conversion_function) : deferred_(deferred),
                                                              conversion_function_(conversion_function) {}

        void set_up() {
            auto resolver = Napi::Function::New(deferred_.Env(), [me = this->shared_from_this()]
                    (const auto &info) -> Napi::Value {
                if (info.Env() != me->deferred_.Env())
                    throw std::logic_error("generic_callback_wrapper: Napi Environments not equal");
                me->set_deferred();
                return info.Env().Undefined();
            });
            function_ = Napi::ThreadSafeFunction::New(deferred_.Env(), resolver, "Generic callback wrapepr", 0, 1);
        }

        void set_deferred() {
            try {
                auto value = std::invoke(conversion_function_, deferred_.Env(), std::move(result_));
                deferred_.Resolve(value);
            } catch (Napi::Error &e) {
                deferred_.Reject(e.Value());
            } catch (std::exception &e) {
                deferred_.Reject(Napi::Error::New(deferred_.Env(), e.what()).Value());
            } catch (...) {
                deferred_.Reject(Napi::Error::New(deferred_.Env()).Value());
            }
        }

        callback_t get_native_callback() {
            return [me = this->shared_from_this()](auto &&future) {
                me->native_callback(std::forward<decltype(future)>(future));
            };
        }

        void native_callback(std::future<T> &&future) {
            this->result_ = std::forward<decltype(future)>(future);
            this->function_.BlockingCall();
            function_.Release();
        }
    };

    std::shared_ptr<internal> internal_;

};

#include <napi.h>

#include <functional>
#include <future>
#include <memory>
#include <utility>


template<typename T>
class generic_subscription_wrapper {
public:
    using js_callback_t = Napi::Function;
    using callback_t = std::function<void(std::shared_future<T>)>;
    using conversion_function_t = std::function<Napi::Value(const Napi::Env &, const std::shared_future<T> &)>;
    using unsubscribe_function_t = std::function<void(void)>;

    generic_subscription_wrapper(const Napi::Promise::Deferred &deferred,
                                 conversion_function_t conversion_function, js_callback_t js_function)
            : internal_(std::make_shared<internal>(deferred, conversion_function, js_function)) {
        internal_->set_up();
    }

    template<typename F>
    void set_unsubscription_function(F &&unsubscribe_function) {
        internal_->unsubscribe_function_ = std::forward<F>(unsubscribe_function);
    }

    callback_t get_native_callback() {
        return internal_->get_native_callback();
    }


private:
    struct internal : std::enable_shared_from_this<internal> {
        Napi::Promise::Deferred deferred_;
        Napi::ThreadSafeFunction function_;
        Napi::Reference<Napi::Function> js_function_;
        Napi::Function conversion_wrapper_;
        conversion_function_t conversion_function_;
        std::shared_future<T> result_;
        unsubscribe_function_t unsubscribe_function_;

        internal(const Napi::Promise::Deferred &deferred,
                 conversion_function_t conversion_function, js_callback_t js_function) :
                deferred_(deferred), conversion_function_(conversion_function),
                js_function_(Napi::Persistent(js_function)) {}

        void set_up() {
            conversion_wrapper_ = Napi::Function::New(deferred_.Env(), [me = this->shared_from_this()]
                    (const auto &info) -> Napi::Value {
                if (info.Env() != me->deferred_.Env())
                    throw std::logic_error("generic_callback_wrapper: Napi Environments not equal");

                me->set_deferred();

                return info.Env().Undefined();
            });
            function_ = Napi::ThreadSafeFunction::New(deferred_.Env(), conversion_wrapper_,
                                                      "Generic subscription wrapper", 1, 1);

            auto unsubscribe_call = Napi::Function::New(deferred_.Env(),
                                                        [me = this->shared_from_this()](const auto &info) {
                                                            std::invoke(me->unsubscribe_function_);
                                                            me->tear_down();
                                                        });
            deferred_.Resolve(unsubscribe_call);
        }

        void tear_down() {
            function_.Release();
        }

        callback_t get_native_callback() {
            return [me = this->shared_from_this()](auto &&future) {
                me->native_callback(std::forward<decltype(future)>(future));
            };
        }

        void native_callback(std::shared_future<T> &&future) {
            result_ = std::forward<decltype(future)>(future);
            this->function_.BlockingCall();
        }

        void set_deferred() {
            Napi::Value value;
            try {
                value = std::invoke(conversion_function_, deferred_.Env(), std::move(result_));
            } catch (Napi::Error &e) {
                value = e.Value();
            } catch (std::exception &e) {
                value = Napi::Error::New(deferred_.Env(), e.what()).Value();
            } catch (...) {
                value = Napi::Error::New(deferred_.Env()).Value();
            }
            js_function_.Value().Call({value});
        }
    };

    std::shared_ptr<internal> internal_;

};

This issue is stale because it has been open many days with no activity. It will be closed soon unless the stale label is removed or a comment is made.

There is an active PR related to this: #804

Navigation Menu

Repository navigation

Add facilities to ease usage of async native patterns like boost::asio #803

Metadata

Assignees

Labels

Type

Projects

Milestone

Relationships

Development

Add facilities to ease usage of async native patterns like boost::asio #803

Description

Activity

Superlokkus commented on Sep 24, 2020

github-actions commented on Dec 24, 2020

mhdawson commented on Dec 24, 2020

Metadata

Metadata

Assignees

Labels

Type

Projects

Milestone

Relationships

Development

Issue actions