koffi 1.1.0-beta.1 → 1.1.0-beta.2

package/vendor/node-addon-api/test/threadsafe_function/threadsafe_function.cc

@@ -0,0 +1,195 @@
+#include <chrono>
+#include <condition_variable>
+#include <mutex>
+#include <thread>
+#include "napi.h"
+
+#if (NAPI_VERSION > 3)
+
+using namespace Napi;
+
+constexpr size_t ARRAY_LENGTH = 10;
+constexpr size_t MAX_QUEUE_SIZE = 2;
+
+static std::thread threads[2];
+static ThreadSafeFunction tsfn;
+
+struct ThreadSafeFunctionInfo {
+  enum CallType {
+    DEFAULT,
+    BLOCKING,
+    NON_BLOCKING
+  } type;
+  bool abort;
+  bool startSecondary;
+  FunctionReference jsFinalizeCallback;
+  uint32_t maxQueueSize;
+  bool closeCalledFromJs;
+  std::mutex protect;
+  std::condition_variable signal;
+} tsfnInfo;
+
+// Thread data to transmit to JS
+static int ints[ARRAY_LENGTH];
+
+static void SecondaryThread() {
+  if (tsfn.Release() != napi_ok) {
+    Error::Fatal("SecondaryThread", "ThreadSafeFunction.Release() failed");
+  }
+}
+
+// Source thread producing the data
+static void DataSourceThread() {
+  ThreadSafeFunctionInfo* info = tsfn.GetContext();
+
+  if (info->startSecondary) {
+    if (tsfn.Acquire() != napi_ok) {
+      Error::Fatal("DataSourceThread", "ThreadSafeFunction.Acquire() failed");
+    }
+
+    threads[1] = std::thread(SecondaryThread);
+  }
+
+  bool queueWasFull = false;
+  bool queueWasClosing = false;
+  for (int index = ARRAY_LENGTH - 1; index > -1 && !queueWasClosing; index--) {
+    napi_status status = napi_generic_failure;
+    auto callback = [](Env env, Function jsCallback, int* data) {
+      jsCallback.Call({ Number::New(env, *data) });
+    };
+
+    switch (info->type) {
+      case ThreadSafeFunctionInfo::DEFAULT:
+        status = tsfn.BlockingCall();
+        break;
+      case ThreadSafeFunctionInfo::BLOCKING:
+        status = tsfn.BlockingCall(&ints[index], callback);
+        break;
+      case ThreadSafeFunctionInfo::NON_BLOCKING:
+        status = tsfn.NonBlockingCall(&ints[index], callback);
+        break;
+    }
+
+    if (info->abort && info->type != ThreadSafeFunctionInfo::NON_BLOCKING) {
+      // Let's make this thread really busy to give the main thread a chance to
+      // abort / close.
+      std::unique_lock<std::mutex> lk(info->protect);
+      while (!info->closeCalledFromJs) {
+        info->signal.wait(lk);
+      }
+    }
+
+    switch (status) {
+    case napi_queue_full:
+      queueWasFull = true;
+      index++;
+      // fall through
+
+    case napi_ok:
+      continue;
+
+    case napi_closing:
+      queueWasClosing = true;
+      break;
+
+    default:
+      Error::Fatal("DataSourceThread", "ThreadSafeFunction.*Call() failed");
+    }
+  }
+
+  if (info->type == ThreadSafeFunctionInfo::NON_BLOCKING && !queueWasFull) {
+    Error::Fatal("DataSourceThread", "Queue was never full");
+  }
+
+  if (info->abort && !queueWasClosing) {
+    Error::Fatal("DataSourceThread", "Queue was never closing");
+  }
+
+  if (!queueWasClosing && tsfn.Release() != napi_ok) {
+    Error::Fatal("DataSourceThread", "ThreadSafeFunction.Release() failed");
+  }
+}
+
+static Value StopThread(const CallbackInfo& info) {
+  tsfnInfo.jsFinalizeCallback = Napi::Persistent(info[0].As<Function>());
+  bool abort = info[1].As<Boolean>();
+  if (abort) {
+    tsfn.Abort();
+  } else {
+    tsfn.Release();
+  }
+  {
+    std::lock_guard<std::mutex> _(tsfnInfo.protect);
+    tsfnInfo.closeCalledFromJs = true;
+    tsfnInfo.signal.notify_one();
+  }
+  return Value();
+}
+
+// Join the thread and inform JS that we're done.
+static void JoinTheThreads(Env /* env */,
+                           std::thread* theThreads,
+                           ThreadSafeFunctionInfo* info) {
+  theThreads[0].join();
+  if (info->startSecondary) {
+    theThreads[1].join();
+  }
+
+  info->jsFinalizeCallback.Call({});
+  info->jsFinalizeCallback.Reset();
+}
+
+static Value StartThreadInternal(const CallbackInfo& info,
+    ThreadSafeFunctionInfo::CallType type) {
+  tsfnInfo.type = type;
+  tsfnInfo.abort = info[1].As<Boolean>();
+  tsfnInfo.startSecondary = info[2].As<Boolean>();
+  tsfnInfo.maxQueueSize = info[3].As<Number>().Uint32Value();
+  tsfnInfo.closeCalledFromJs = false;
+
+  tsfn = ThreadSafeFunction::New(info.Env(), info[0].As<Function>(),
+      "Test", tsfnInfo.maxQueueSize, 2, &tsfnInfo, JoinTheThreads, threads);
+
+  threads[0] = std::thread(DataSourceThread);
+
+  return Value();
+}
+
+static Value Release(const CallbackInfo& /* info */) {
+  if (tsfn.Release() != napi_ok) {
+    Error::Fatal("Release", "ThreadSafeFunction.Release() failed");
+  }
+  return Value();
+}
+
+static Value StartThread(const CallbackInfo& info) {
+  return StartThreadInternal(info, ThreadSafeFunctionInfo::BLOCKING);
+}
+
+static Value StartThreadNonblocking(const CallbackInfo& info) {
+  return StartThreadInternal(info, ThreadSafeFunctionInfo::NON_BLOCKING);
+}
+
+static Value StartThreadNoNative(const CallbackInfo& info) {
+  return StartThreadInternal(info, ThreadSafeFunctionInfo::DEFAULT);
+}
+
+Object InitThreadSafeFunction(Env env) {
+  for (size_t index = 0; index < ARRAY_LENGTH; index++) {
+    ints[index] = index;
+  }
+
+  Object exports = Object::New(env);
+  exports["ARRAY_LENGTH"] = Number::New(env, ARRAY_LENGTH);
+  exports["MAX_QUEUE_SIZE"] = Number::New(env, MAX_QUEUE_SIZE);
+  exports["startThread"] = Function::New(env, StartThread);
+  exports["startThreadNoNative"] = Function::New(env, StartThreadNoNative);
+  exports["startThreadNonblocking"] =
+      Function::New(env, StartThreadNonblocking);
+  exports["stopThread"] = Function::New(env, StopThread);
+  exports["release"] = Function::New(env, Release);
+
+  return exports;
+}
+
+#endif

package/vendor/node-addon-api/test/threadsafe_function/threadsafe_function.js

@@ -0,0 +1,188 @@
+'use strict';
+
+const assert = require('assert');
+const common = require('../common');
+
+module.exports = common.runTest(test);
+
+async function test(binding) {
+  const expectedArray = (function(arrayLength) {
+    const result = [];
+    for (let index = 0; index < arrayLength; index++) {
+      result.push(arrayLength - 1 - index);
+    }
+    return result;
+  })(binding.threadsafe_function.ARRAY_LENGTH);
+
+  function testWithJSMarshaller({
+    threadStarter,
+    quitAfter,
+    abort,
+    maxQueueSize,
+    launchSecondary }) {
+    return new Promise((resolve) => {
+      const array = [];
+      binding.threadsafe_function[threadStarter](function testCallback(value) {
+        array.push(value);
+        if (array.length === quitAfter) {
+          binding.threadsafe_function.stopThread(common.mustCall(() => {
+            resolve(array);
+          }), !!abort);
+        }
+      }, !!abort, !!launchSecondary, maxQueueSize);
+      if (threadStarter === 'startThreadNonblocking') {
+        // Let's make this thread really busy for a short while to ensure that
+        // the queue fills and the thread receives a napi_queue_full.
+        const start = Date.now();
+        while (Date.now() - start < 200);
+      }
+    });
+  }
+
+  await new Promise(function testWithoutJSMarshaller(resolve) {
+    let callCount = 0;
+    binding.threadsafe_function.startThreadNoNative(function testCallback() {
+      callCount++;
+
+      // The default call-into-JS implementation passes no arguments.
+      assert.strictEqual(arguments.length, 0);
+      if (callCount === binding.threadsafe_function.ARRAY_LENGTH) {
+        setImmediate(() => {
+          binding.threadsafe_function.stopThread(common.mustCall(() => {
+            resolve();
+          }), false);
+        });
+      }
+    }, false /* abort */, false /* launchSecondary */,
+    binding.threadsafe_function.MAX_QUEUE_SIZE);
+  });
+
+  // Start the thread in blocking mode, and assert that all values are passed.
+  // Quit after it's done.
+  assert.deepStrictEqual(
+    await testWithJSMarshaller({
+      threadStarter: 'startThread',
+      maxQueueSize: binding.threadsafe_function.MAX_QUEUE_SIZE,
+      quitAfter: binding.threadsafe_function.ARRAY_LENGTH
+    }),
+    expectedArray,
+  );
+
+  // Start the thread in blocking mode with an infinite queue, and assert that
+  // all values are passed. Quit after it's done.
+  assert.deepStrictEqual(
+    await testWithJSMarshaller({
+      threadStarter: 'startThread',
+      maxQueueSize: 0,
+      quitAfter: binding.threadsafe_function.ARRAY_LENGTH
+    }),
+    expectedArray,
+  );
+
+  // Start the thread in non-blocking mode, and assert that all values are
+  // passed. Quit after it's done.
+  assert.deepStrictEqual(
+    await testWithJSMarshaller({
+      threadStarter: 'startThreadNonblocking',
+      maxQueueSize: binding.threadsafe_function.MAX_QUEUE_SIZE,
+      quitAfter: binding.threadsafe_function.ARRAY_LENGTH
+    }),
+    expectedArray,
+  );
+
+  // Start the thread in blocking mode, and assert that all values are passed.
+  // Quit early, but let the thread finish.
+  assert.deepStrictEqual(
+    await testWithJSMarshaller({
+      threadStarter: 'startThread',
+      maxQueueSize: binding.threadsafe_function.MAX_QUEUE_SIZE,
+      quitAfter: 1
+    }),
+    expectedArray,
+  );
+
+  // Start the thread in blocking mode with an infinite queue, and assert that
+  // all values are passed. Quit early, but let the thread finish.
+  assert.deepStrictEqual(
+    await testWithJSMarshaller({
+      threadStarter: 'startThread',
+      maxQueueSize: 0,
+      quitAfter: 1
+    }),
+    expectedArray,
+  );
+
+
+  // Start the thread in non-blocking mode, and assert that all values are
+  // passed. Quit early, but let the thread finish.
+  assert.deepStrictEqual(
+    await testWithJSMarshaller({
+      threadStarter: 'startThreadNonblocking',
+      maxQueueSize: binding.threadsafe_function.MAX_QUEUE_SIZE,
+      quitAfter: 1
+    }),
+    expectedArray,
+  );
+
+  // Start the thread in blocking mode, and assert that all values are passed.
+  // Quit early, but let the thread finish. Launch a secondary thread to test
+  // the reference counter incrementing functionality.
+  assert.deepStrictEqual(
+    await testWithJSMarshaller({
+      threadStarter: 'startThread',
+      quitAfter: 1,
+      maxQueueSize: binding.threadsafe_function.MAX_QUEUE_SIZE,
+      launchSecondary: true
+    }),
+    expectedArray,
+  );
+
+  // Start the thread in non-blocking mode, and assert that all values are
+  // passed. Quit early, but let the thread finish. Launch a secondary thread
+  // to test the reference counter incrementing functionality.
+  assert.deepStrictEqual(
+    await testWithJSMarshaller({
+      threadStarter: 'startThreadNonblocking',
+      quitAfter: 1,
+      maxQueueSize: binding.threadsafe_function.MAX_QUEUE_SIZE,
+      launchSecondary: true
+    }),
+    expectedArray,
+  );
+
+  // Start the thread in blocking mode, and assert that it could not finish.
+  // Quit early by aborting.
+  assert.strictEqual(
+    (await testWithJSMarshaller({
+      threadStarter: 'startThread',
+      quitAfter: 1,
+      maxQueueSize: binding.threadsafe_function.MAX_QUEUE_SIZE,
+      abort: true
+    })).indexOf(0),
+    -1,
+  );
+
+  // Start the thread in blocking mode with an infinite queue, and assert that
+  // it could not finish. Quit early by aborting.
+  assert.strictEqual(
+    (await testWithJSMarshaller({
+      threadStarter: 'startThread',
+      quitAfter: 1,
+      maxQueueSize: 0,
+      abort: true
+    })).indexOf(0),
+    -1,
+  );
+
+  // Start the thread in non-blocking mode, and assert that it could not finish.
+  // Quit early and aborting.
+  assert.strictEqual(
+    (await testWithJSMarshaller({
+      threadStarter: 'startThreadNonblocking',
+      quitAfter: 1,
+      maxQueueSize: binding.threadsafe_function.MAX_QUEUE_SIZE,
+      abort: true
+    })).indexOf(0),
+    -1,
+  );
+}

package/vendor/node-addon-api/test/threadsafe_function/threadsafe_function_ctx.cc

@@ -0,0 +1,63 @@
+#include "napi.h"
+
+#if (NAPI_VERSION > 3)
+
+using namespace Napi;
+
+namespace {
+
+class TSFNWrap : public ObjectWrap<TSFNWrap> {
+public:
+  static Object Init(Napi::Env env, Object exports);
+  TSFNWrap(const CallbackInfo &info);
+
+  Napi::Value GetContext(const CallbackInfo & /*info*/) {
+    Reference<Napi::Value> *ctx = _tsfn.GetContext();
+    return ctx->Value();
+  };
+
+  Napi::Value Release(const CallbackInfo &info) {
+    Napi::Env env = info.Env();
+    _deferred = std::unique_ptr<Promise::Deferred>(new Promise::Deferred(env));
+    _tsfn.Release();
+    return _deferred->Promise();
+  };
+
+private:
+  ThreadSafeFunction _tsfn;
+  std::unique_ptr<Promise::Deferred> _deferred;
+};
+
+Object TSFNWrap::Init(Napi::Env env, Object exports) {
+  Function func =
+      DefineClass(env, "TSFNWrap",
+                  {InstanceMethod("getContext", &TSFNWrap::GetContext),
+                   InstanceMethod("release", &TSFNWrap::Release)});
+
+  exports.Set("TSFNWrap", func);
+  return exports;
+}
+
+TSFNWrap::TSFNWrap(const CallbackInfo &info) : ObjectWrap<TSFNWrap>(info) {
+  Napi::Env env = info.Env();
+
+  Reference<Napi::Value> *_ctx = new Reference<Napi::Value>;
+  *_ctx = Persistent(info[0]);
+
+  _tsfn = ThreadSafeFunction::New(
+      info.Env(), Function::New(env, [](const CallbackInfo & /*info*/) {}),
+      Object::New(env), "Test", 1, 1, _ctx,
+      [this](Napi::Env env, Reference<Napi::Value> *ctx) {
+        _deferred->Resolve(env.Undefined());
+        ctx->Reset();
+        delete ctx;
+      });
+}
+
+} // namespace
+
+Object InitThreadSafeFunctionCtx(Env env) {
+  return TSFNWrap::Init(env, Object::New(env));
+}
+
+#endif

package/vendor/node-addon-api/test/threadsafe_function/threadsafe_function_ctx.js

@@ -0,0 +1,12 @@
+'use strict';
+
+const assert = require('assert');
+
+module.exports = require('../common').runTest(test);
+
+async function test(binding) {
+  const ctx = { };
+  const tsfn = new binding.threadsafe_function_ctx.TSFNWrap(ctx);
+  assert(tsfn.getContext() === ctx);
+  await tsfn.release();
+}

package/vendor/node-addon-api/test/threadsafe_function/threadsafe_function_existing_tsfn.cc

@@ -0,0 +1,115 @@
+#include <cstdlib>
+#include "napi.h"
+#include "test_helper.h"
+
+#if (NAPI_VERSION > 3)
+
+using namespace Napi;
+
+namespace {
+
+struct TestContext {
+  TestContext(Promise::Deferred &&deferred)
+      : deferred(std::move(deferred)), callData(nullptr){};
+
+  napi_threadsafe_function tsfn;
+  Promise::Deferred deferred;
+  double *callData;
+
+  ~TestContext() {
+    if (callData != nullptr)
+      delete callData;
+  };
+};
+
+void FinalizeCB(napi_env env, void * /*finalizeData */, void *context) {
+  TestContext *testContext = static_cast<TestContext *>(context);
+  if (testContext->callData != nullptr) {
+    testContext->deferred.Resolve(Number::New(env, *testContext->callData));
+  } else {
+    testContext->deferred.Resolve(Napi::Env(env).Undefined());
+  }
+  delete testContext;
+}
+
+void CallJSWithData(napi_env env, napi_value /* callback */, void *context,
+                    void *data) {
+  TestContext *testContext = static_cast<TestContext *>(context);
+  testContext->callData = static_cast<double *>(data);
+
+  napi_status status =
+      napi_release_threadsafe_function(testContext->tsfn, napi_tsfn_release);
+
+  NAPI_THROW_IF_FAILED_VOID(env, status);
+}
+
+void CallJSNoData(napi_env env, napi_value /* callback */, void *context,
+                  void * /*data*/) {
+  TestContext *testContext = static_cast<TestContext *>(context);
+  testContext->callData = nullptr;
+
+  napi_status status =
+      napi_release_threadsafe_function(testContext->tsfn, napi_tsfn_release);
+
+  NAPI_THROW_IF_FAILED_VOID(env, status);
+}
+
+static Value TestCall(const CallbackInfo &info) {
+  Napi::Env env = info.Env();
+  bool isBlocking = false;
+  bool hasData = false;
+  if (info.Length() > 0) {
+    Object opts = info[0].As<Object>();
+    bool hasProperty = MaybeUnwrap(opts.Has("blocking"));
+    if (hasProperty) {
+      isBlocking = MaybeUnwrap(MaybeUnwrap(opts.Get("blocking")).ToBoolean());
+    }
+    hasProperty = MaybeUnwrap(opts.Has("data"));
+    if (hasProperty) {
+      hasData = MaybeUnwrap(MaybeUnwrap(opts.Get("data")).ToBoolean());
+    }
+  }
+
+  // Allow optional callback passed from JS. Useful for testing.
+  Function cb = Function::New(env, [](const CallbackInfo & /*info*/) {});
+
+  TestContext *testContext = new TestContext(Napi::Promise::Deferred(env));
+
+  napi_status status = napi_create_threadsafe_function(
+      env, cb, Object::New(env), String::New(env, "Test"), 0, 1,
+      nullptr, /*finalize data*/
+      FinalizeCB, testContext, hasData ? CallJSWithData : CallJSNoData,
+      &testContext->tsfn);
+
+  NAPI_THROW_IF_FAILED(env, status, Value());
+
+  ThreadSafeFunction wrapped = ThreadSafeFunction(testContext->tsfn);
+
+  // Test the four napi_threadsafe_function direct-accessing calls
+  if (isBlocking) {
+    if (hasData) {
+      wrapped.BlockingCall(static_cast<void *>(new double(std::rand())));
+    } else {
+      wrapped.BlockingCall(static_cast<void *>(nullptr));
+    }
+  } else {
+    if (hasData) {
+      wrapped.NonBlockingCall(static_cast<void *>(new double(std::rand())));
+    } else {
+      wrapped.NonBlockingCall(static_cast<void *>(nullptr));
+    }
+  }
+
+  return testContext->deferred.Promise();
+}
+
+} // namespace
+
+Object InitThreadSafeFunctionExistingTsfn(Env env) {
+  Object exports = Object::New(env);
+  exports["testCall"] = Function::New(env, TestCall);
+
+  return exports;
+}
+
+#endif

package/vendor/node-addon-api/test/threadsafe_function/threadsafe_function_existing_tsfn.js

@@ -0,0 +1,14 @@
+'use strict';
+
+const assert = require('assert');
+
+module.exports = require('../common').runTest(test);
+
+async function test(binding) {
+  const testCall = binding.threadsafe_function_existing_tsfn.testCall;
+
+  assert.strictEqual(typeof await testCall({ blocking: true,  data: true  }), "number");
+  assert.strictEqual(typeof await testCall({ blocking: true,  data: false }), "undefined");
+  assert.strictEqual(typeof await testCall({ blocking: false, data: true  }), "number");
+  assert.strictEqual(typeof await testCall({ blocking: false, data: false }), "undefined");
+}

package/vendor/node-addon-api/test/threadsafe_function/threadsafe_function_ptr.cc

@@ -0,0 +1,26 @@
+#include "napi.h"
+
+#if (NAPI_VERSION > 3)
+
+using namespace Napi;
+
+namespace {
+
+static Value Test(const CallbackInfo& info) {
+  Object resource = info[0].As<Object>();
+  Function cb = info[1].As<Function>();
+  ThreadSafeFunction tsfn = ThreadSafeFunction::New(info.Env(), cb, resource, "Test", 1, 1);
+  tsfn.Release();
+  return info.Env().Undefined();
+}
+
+}
+
+Object InitThreadSafeFunctionPtr(Env env) {
+  Object exports = Object::New(env);
+  exports["test"] = Function::New(env, Test);
+
+  return exports;
+}
+
+#endif

package/vendor/node-addon-api/test/threadsafe_function/threadsafe_function_ptr.js

@@ -0,0 +1,7 @@
+'use strict';
+
+module.exports = require('../common').runTest(test);
+
+function test(binding) {
+  binding.threadsafe_function_ptr.test({}, () => {});
+}