Skip to content
New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

AsyncWorker: add GetResult() method #512

Closed
wants to merge 2 commits into from
Closed
Changes from 1 commit
Commits
File filter

Filter by extension

Filter by extension

Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
14 changes: 12 additions & 2 deletions doc/async_worker.md
Original file line number Diff line number Diff line change
@@ -79,7 +79,7 @@ the `Napi::AsyncWorker::OnOK` callback.

Sets the error message for the error that happened during the execution. Setting
an error message will cause the `Napi::AsyncWorker::OnError` method to be
invoked instead of `Napi::AsyncWorker::OnOKOnOK` once the
invoked instead of `Napi::AsyncWorker::OnOK` once the
`Napi::AsyncWorker::Execute` method completes.

```cpp
@@ -107,11 +107,21 @@ virtual void Napi::AsyncWorker::Execute() = 0;

This method is invoked when the computation in the `Execute` method ends.
The default implementation runs the Callback optionally provided when the AsyncWorker class
was created.
was created. The callback will by default receive no arguments. To provide arguments,
override the `GetResult()` method.

```cpp
virtual void Napi::AsyncWorker::OnOK();
```
### GetResult

This method returns the arguments passed to the Callback invoked by the default
`OnOK()` implementation. The default implementation returns an empty vector,
providing no arguments to the Callback.

```cpp
virtual std::vector<napi_value> Napi::AsyncWorker::GetResult(Napi::Env env);
```

### OnError

10 changes: 8 additions & 2 deletions napi-inl.h
Original file line number Diff line number Diff line change
@@ -3686,7 +3686,7 @@ inline void AsyncWorker::SuppressDestruct() {

inline void AsyncWorker::OnOK() {
if (!_callback.IsEmpty()) {
_callback.Call(_receiver.Value(), std::initializer_list<napi_value>{});
_callback.Call(_receiver.Value(), GetResult(_callback.Env()));
}
}

@@ -3700,7 +3700,13 @@ inline void AsyncWorker::SetError(const std::string& error) {
_error = error;
}

inline void AsyncWorker::OnExecute(napi_env /*env*/, void* this_pointer) {
inline std::vector<napi_value> AsyncWorker::GetResult(Napi::Env env) {
return {};
}
// The OnExecute method receives an napi_env argument. However, do NOT
// use it within this method, as it does not run on the main thread and cannot
// access the napi_env.
Copy link
Member

@mhdawson mhdawson Jul 16, 2019

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

Maybe use the following instead:

as it does not run on the main thread and must not run any method that would cause
JavaScript to run. In practice, this means that almost any use of napi_env will be incorrect.

Copy link
Contributor Author

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

Updated.

inline void AsyncWorker::OnExecute(napi_env /*DO_NOT_USE*/, void* this_pointer) {
AsyncWorker* self = static_cast<AsyncWorker*>(this_pointer);
#ifdef NAPI_CPP_EXCEPTIONS
try {
1 change: 1 addition & 0 deletions napi.h
Original file line number Diff line number Diff line change
@@ -1812,6 +1812,7 @@ namespace Napi {
virtual void OnOK();
virtual void OnError(const Error& e);
virtual void Destroy();
virtual std::vector<napi_value> GetResult(Napi::Env env);
KevinEady marked this conversation as resolved.
Show resolved Hide resolved

void SetError(const std::string& error);

12 changes: 12 additions & 0 deletions test/asyncworker.cc
Original file line number Diff line number Diff line change
@@ -9,14 +9,25 @@ class TestWorker : public AsyncWorker {
Object resource = info[1].As<Object>();
Function cb = info[2].As<Function>();
Value data = info[3];
bool setResult = info[4].As<Boolean>();

TestWorker* worker = new TestWorker(cb, "TestResource", resource);
worker->Receiver().Set("data", data);
worker->_succeed = succeed;
worker->_setResult = setResult;
worker->Queue();
}

protected:
std::vector<napi_value> GetResult(Napi::Env env) override {
KevinEady marked this conversation as resolved.
Show resolved Hide resolved
if (_setResult)
return {Boolean::New(env, _succeed),
String::New(env, _succeed ? "ok" : "error")};
else {
return {};
}
}

void Execute() override {
if (!_succeed) {
SetError("test error");
@@ -27,6 +38,7 @@ class TestWorker : public AsyncWorker {
TestWorker(Function cb, const char* resource_name, const Object& resource)
: AsyncWorker(cb, resource_name, resource) {}
bool _succeed;
bool _setResult;
};

class TestWorkerNoCallback : public AsyncWorker {
43 changes: 39 additions & 4 deletions test/asyncworker.js
Original file line number Diff line number Diff line change
@@ -58,14 +58,24 @@ function test(binding) {
assert.strictEqual(typeof e, 'undefined');
assert.strictEqual(typeof this, 'object');
assert.strictEqual(this.data, 'test data');
}, 'test data');
}, 'test data', false);

binding.asyncworker.doWork(true, {}, function (succeed, succeedString) {
assert(arguments.length == 2);
assert(succeed);
assert(succeedString == "ok");
assert.strictEqual(typeof e, 'undefined');
assert.strictEqual(typeof this, 'object');
assert.strictEqual(this.data, 'test data');
console.log("ok!");
}, 'test data', true);

binding.asyncworker.doWork(false, {}, function (e) {
assert.ok(e instanceof Error);
assert.strictEqual(e.message, 'test error');
assert.strictEqual(typeof this, 'object');
assert.strictEqual(this.data, 'test data');
}, 'test data');
}, 'test data', false);
return;
}

@@ -76,7 +86,32 @@ function test(binding) {
assert.strictEqual(typeof e, 'undefined');
assert.strictEqual(typeof this, 'object');
assert.strictEqual(this.data, 'test data');
}, 'test data');
}, 'test data', false);

hooks.then(actual => {
assert.deepStrictEqual(actual, [
{ eventName: 'init',
type: 'TestResource',
triggerAsyncId: triggerAsyncId,
resource: { foo: 'foo' } },
{ eventName: 'before' },
{ eventName: 'after' },
{ eventName: 'destroy' }
]);
}).catch(common.mustNotCall());
}


{
const hooks = installAsyncHooksForTest();
const triggerAsyncId = async_hooks.executionAsyncId();
binding.asyncworker.doWork(true, { foo: 'foo' }, function (succeed, succeedString) {
assert(arguments.length == 2);
assert(succeed);
assert(succeedString == "ok");
assert.strictEqual(typeof this, 'object');
assert.strictEqual(this.data, 'test data');
}, 'test data', true);

hooks.then(actual => {
assert.deepStrictEqual(actual, [
@@ -100,7 +135,7 @@ function test(binding) {
assert.strictEqual(e.message, 'test error');
assert.strictEqual(typeof this, 'object');
assert.strictEqual(this.data, 'test data');
}, 'test data');
}, 'test data', false);

hooks.then(actual => {
assert.deepStrictEqual(actual, [