lukechilds
/
node
mirror of https://github.com/lukechilds/node.git
1
0
Fork 0
Code Issues Projects Releases Wiki Activity
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
9639 Commits
131 Branches
446 Tags
325 MiB
Tree: c9abb59638
Branches Tags
${ item.name }
Create tag ${ searchTerm }
Create branch ${ searchTerm }
from 'c9abb59638'
${ noResults }
node/src/async-wrap-inl.h

248 lines
6.4 KiB
Raw Normal View History

node: add AsyncListener support AsyncListener is a JS API that works in tandem with the AsyncWrap class to allow the user to be alerted to key events in the life cycle of an asynchronous event. The AsyncWrap class has its own MakeCallback implementation that core will be migrated to use, and uses state sharing techniques to allow quicker communication between JS and C++ whether the async event callbacks need to be called.
11 years ago
// Copyright Joyent, Inc. and other Node contributors.
//
// Permission is hereby granted, free of charge, to any person obtaining a
// copy of this software and associated documentation files (the
// "Software"), to deal in the Software without restriction, including
// without limitation the rights to use, copy, modify, merge, publish,
// distribute, sublicense, and/or sell copies of the Software, and to permit
// persons to whom the Software is furnished to do so, subject to the
// following conditions:
//
// The above copyright notice and this permission notice shall be included
// in all copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
// USE OR OTHER DEALINGS IN THE SOFTWARE.
#ifndef SRC_ASYNC_WRAP_INL_H_
#define SRC_ASYNC_WRAP_INL_H_
#include "async-wrap.h"
base-object: add BaseObject BaseObject is a class that just handles the Persistent handle attached to the class instance. This also removed WeakObject. Reordering the inheritance chain helps prevent unneeded calls on instances that don't call MakeCallback.
11 years ago
#include "base-object.h"
#include "base-object-inl.h"
node: add AsyncListener support AsyncListener is a JS API that works in tandem with the AsyncWrap class to allow the user to be alerted to key events in the life cycle of an asynchronous event. The AsyncWrap class has its own MakeCallback implementation that core will be migrated to use, and uses state sharing techniques to allow quicker communication between JS and C++ whether the async event callbacks need to be called.
11 years ago
#include "env.h"
#include "env-inl.h"
#include "util.h"
#include "util-inl.h"
base-object: add BaseObject BaseObject is a class that just handles the Persistent handle attached to the class instance. This also removed WeakObject. Reordering the inheritance chain helps prevent unneeded calls on instances that don't call MakeCallback.
11 years ago
node: add AsyncListener support AsyncListener is a JS API that works in tandem with the AsyncWrap class to allow the user to be alerted to key events in the life cycle of an asynchronous event. The AsyncWrap class has its own MakeCallback implementation that core will be migrated to use, and uses state sharing techniques to allow quicker communication between JS and C++ whether the async event callbacks need to be called.
11 years ago
#include "v8.h"
#include <assert.h>
namespace node {
inline AsyncWrap::AsyncWrap(Environment* env, v8::Handle<v8::Object> object)
base-object: add BaseObject BaseObject is a class that just handles the Persistent handle attached to the class instance. This also removed WeakObject. Reordering the inheritance chain helps prevent unneeded calls on instances that don&#39;t call MakeCallback.
11 years ago
: BaseObject(env, object),
node: add AsyncListener support AsyncListener is a JS API that works in tandem with the AsyncWrap class to allow the user to be alerted to key events in the life cycle of an asynchronous event. The AsyncWrap class has its own MakeCallback implementation that core will be migrated to use, and uses state sharing techniques to allow quicker communication between JS and C++ whether the async event callbacks need to be called.
11 years ago
async_flags_(NO_OPTIONS) {
node: AsyncListener use separate storage mechanism Before when an AsyncListener object was created and the &#34;create&#34; callback returned a value, it was necessary to construct a new Object with the same callbacks but add a place for the new storage value. Now, instead, a separate storage array is kept on the context which is used for any return value of the &#34;create&#34; callback. This significantly reduces the number of Objects that need to be created. Also added a flags property to the context to quickly check if a specific callback was available either on the context or on the AsyncListener instance itself. Few other minor changes for readability that were difficult to separate into their own commit. This has not been optimized yet.
11 years ago
if (!env->has_async_listener())
node: add AsyncListener support AsyncListener is a JS API that works in tandem with the AsyncWrap class to allow the user to be alerted to key events in the life cycle of an asynchronous event. The AsyncWrap class has its own MakeCallback implementation that core will be migrated to use, and uses state sharing techniques to allow quicker communication between JS and C++ whether the async event callbacks need to be called.
11 years ago
return;
// TODO(trevnorris): Do we really need to TryCatch this call?
v8::TryCatch try_catch;
try_catch.SetVerbose(true);
v8::Local<v8::Value> val = object.As<v8::Value>();
env->async_listener_run_function()->Call(env->process_object(), 1, &val);
if (!try_catch.HasCaught())
node: AsyncListener use separate storage mechanism Before when an AsyncListener object was created and the &#34;create&#34; callback returned a value, it was necessary to construct a new Object with the same callbacks but add a place for the new storage value. Now, instead, a separate storage array is kept on the context which is used for any return value of the &#34;create&#34; callback. This significantly reduces the number of Objects that need to be created. Also added a flags property to the context to quickly check if a specific callback was available either on the context or on the AsyncListener instance itself. Few other minor changes for readability that were difficult to separate into their own commit. This has not been optimized yet.
11 years ago
async_flags_ |= HAS_ASYNC_LISTENER;
node: add AsyncListener support AsyncListener is a JS API that works in tandem with the AsyncWrap class to allow the user to be alerted to key events in the life cycle of an asynchronous event. The AsyncWrap class has its own MakeCallback implementation that core will be migrated to use, and uses state sharing techniques to allow quicker communication between JS and C++ whether the async event callbacks need to be called.
11 years ago
}
inline AsyncWrap::~AsyncWrap() {
}
inline uint32_t AsyncWrap::async_flags() const {
return async_flags_;
}
node: AsyncListener use separate storage mechanism Before when an AsyncListener object was created and the &#34;create&#34; callback returned a value, it was necessary to construct a new Object with the same callbacks but add a place for the new storage value. Now, instead, a separate storage array is kept on the context which is used for any return value of the &#34;create&#34; callback. This significantly reduces the number of Objects that need to be created. Also added a flags property to the context to quickly check if a specific callback was available either on the context or on the AsyncListener instance itself. Few other minor changes for readability that were difficult to separate into their own commit. This has not been optimized yet.
11 years ago
inline bool AsyncWrap::has_async_listener() {
return async_flags() & HAS_ASYNC_LISTENER;
node: add AsyncListener support AsyncListener is a JS API that works in tandem with the AsyncWrap class to allow the user to be alerted to key events in the life cycle of an asynchronous event. The AsyncWrap class has its own MakeCallback implementation that core will be migrated to use, and uses state sharing techniques to allow quicker communication between JS and C++ whether the async event callbacks need to be called.
11 years ago
}
src: revert domain using AsyncListeners This is a slightly modified revert of bc39bdd. Getting domains to use AsyncListeners became too much of a challenge with many edge cases. While this is still a goal, it will have to be deferred for now until more test coverage can be provided.
11 years ago
// I hate you domains.
inline v8::Handle<v8::Value> AsyncWrap::MakeDomainCallback(
const v8::Handle<v8::Function> cb,
int argc,
v8::Handle<v8::Value>* argv) {
assert(env()->context() == env()->isolate()->GetCurrentContext());
v8::Local<v8::Object> context = object();
v8::Local<v8::Object> process = env()->process_object();
v8::Local<v8::Value> domain_v = context->Get(env()->domain_string());
v8::Local<v8::Object> domain;
v8::TryCatch try_catch;
try_catch.SetVerbose(true);
node: AsyncListener use separate storage mechanism Before when an AsyncListener object was created and the &#34;create&#34; callback returned a value, it was necessary to construct a new Object with the same callbacks but add a place for the new storage value. Now, instead, a separate storage array is kept on the context which is used for any return value of the &#34;create&#34; callback. This significantly reduces the number of Objects that need to be created. Also added a flags property to the context to quickly check if a specific callback was available either on the context or on the AsyncListener instance itself. Few other minor changes for readability that were difficult to separate into their own commit. This has not been optimized yet.
11 years ago
if (has_async_listener()) {
src: revert domain using AsyncListeners This is a slightly modified revert of bc39bdd. Getting domains to use AsyncListeners became too much of a challenge with many edge cases. While this is still a goal, it will have to be deferred for now until more test coverage can be provided.
11 years ago
v8::Local<v8::Value> val = context.As<v8::Value>();
env()->async_listener_load_function()->Call(process, 1, &val);
if (try_catch.HasCaught())
return v8::Undefined(env()->isolate());
}
bool has_domain = domain_v->IsObject();
if (has_domain) {
domain = domain_v.As<v8::Object>();
if (domain->Get(env()->disposed_string())->IsTrue())
return Undefined(env()->isolate());
v8::Local<v8::Function> enter =
domain->Get(env()->enter_string()).As<v8::Function>();
assert(enter->IsFunction());
enter->Call(domain, 0, NULL);
if (try_catch.HasCaught())
return Undefined(env()->isolate());
}
v8::Local<v8::Value> ret = cb->Call(context, argc, argv);
if (try_catch.HasCaught()) {
return Undefined(env()->isolate());
}
if (has_domain) {
v8::Local<v8::Function> exit =
domain->Get(env()->exit_string()).As<v8::Function>();
assert(exit->IsFunction());
exit->Call(domain, 0, NULL);
if (try_catch.HasCaught())
return Undefined(env()->isolate());
}
node: AsyncListener use separate storage mechanism Before when an AsyncListener object was created and the &#34;create&#34; callback returned a value, it was necessary to construct a new Object with the same callbacks but add a place for the new storage value. Now, instead, a separate storage array is kept on the context which is used for any return value of the &#34;create&#34; callback. This significantly reduces the number of Objects that need to be created. Also added a flags property to the context to quickly check if a specific callback was available either on the context or on the AsyncListener instance itself. Few other minor changes for readability that were difficult to separate into their own commit. This has not been optimized yet.
11 years ago
if (has_async_listener()) {
src: revert domain using AsyncListeners This is a slightly modified revert of bc39bdd. Getting domains to use AsyncListeners became too much of a challenge with many edge cases. While this is still a goal, it will have to be deferred for now until more test coverage can be provided.
11 years ago
v8::Local<v8::Value> val = context.As<v8::Value>();
env()->async_listener_unload_function()->Call(process, 1, &val);
if (try_catch.HasCaught())
return Undefined(env()->isolate());
}
Environment::TickInfo* tick_info = env()->tick_info();
if (tick_info->in_tick()) {
return ret;
}
if (tick_info->length() == 0) {
tick_info->set_index(0);
return ret;
}
tick_info->set_in_tick(true);
env()->tick_callback_function()->Call(process, 0, NULL);
tick_info->set_in_tick(false);
if (try_catch.HasCaught()) {
tick_info->set_last_threw(true);
return Undefined(env()->isolate());
}
return ret;
}
node: add AsyncListener support AsyncListener is a JS API that works in tandem with the AsyncWrap class to allow the user to be alerted to key events in the life cycle of an asynchronous event. The AsyncWrap class has its own MakeCallback implementation that core will be migrated to use, and uses state sharing techniques to allow quicker communication between JS and C++ whether the async event callbacks need to be called.
11 years ago
inline v8::Handle<v8::Value> AsyncWrap::MakeCallback(
const v8::Handle<v8::Function> cb,
int argc,
v8::Handle<v8::Value>* argv) {
src: revert domain using AsyncListeners This is a slightly modified revert of bc39bdd. Getting domains to use AsyncListeners became too much of a challenge with many edge cases. While this is still a goal, it will have to be deferred for now until more test coverage can be provided.
11 years ago
if (env()->using_domains())
return MakeDomainCallback(cb, argc, argv);
node: add AsyncListener support AsyncListener is a JS API that works in tandem with the AsyncWrap class to allow the user to be alerted to key events in the life cycle of an asynchronous event. The AsyncWrap class has its own MakeCallback implementation that core will be migrated to use, and uses state sharing techniques to allow quicker communication between JS and C++ whether the async event callbacks need to be called.
11 years ago
assert(env()->context() == env()->isolate()->GetCurrentContext());
v8::Local<v8::Object> context = object();
v8::Local<v8::Object> process = env()->process_object();
v8::TryCatch try_catch;
try_catch.SetVerbose(true);
node: AsyncListener use separate storage mechanism Before when an AsyncListener object was created and the &#34;create&#34; callback returned a value, it was necessary to construct a new Object with the same callbacks but add a place for the new storage value. Now, instead, a separate storage array is kept on the context which is used for any return value of the &#34;create&#34; callback. This significantly reduces the number of Objects that need to be created. Also added a flags property to the context to quickly check if a specific callback was available either on the context or on the AsyncListener instance itself. Few other minor changes for readability that were difficult to separate into their own commit. This has not been optimized yet.
11 years ago
if (has_async_listener()) {
node: add AsyncListener support AsyncListener is a JS API that works in tandem with the AsyncWrap class to allow the user to be alerted to key events in the life cycle of an asynchronous event. The AsyncWrap class has its own MakeCallback implementation that core will be migrated to use, and uses state sharing techniques to allow quicker communication between JS and C++ whether the async event callbacks need to be called.
11 years ago
v8::Local<v8::Value> val = context.As<v8::Value>();
env()->async_listener_load_function()->Call(process, 1, &val);
if (try_catch.HasCaught())
return v8::Undefined(env()->isolate());
}
v8::Local<v8::Value> ret = cb->Call(context, argc, argv);
if (try_catch.HasCaught()) {
return Undefined(env()->isolate());
}
node: AsyncListener use separate storage mechanism Before when an AsyncListener object was created and the &#34;create&#34; callback returned a value, it was necessary to construct a new Object with the same callbacks but add a place for the new storage value. Now, instead, a separate storage array is kept on the context which is used for any return value of the &#34;create&#34; callback. This significantly reduces the number of Objects that need to be created. Also added a flags property to the context to quickly check if a specific callback was available either on the context or on the AsyncListener instance itself. Few other minor changes for readability that were difficult to separate into their own commit. This has not been optimized yet.
11 years ago
if (has_async_listener()) {
node: add AsyncListener support AsyncListener is a JS API that works in tandem with the AsyncWrap class to allow the user to be alerted to key events in the life cycle of an asynchronous event. The AsyncWrap class has its own MakeCallback implementation that core will be migrated to use, and uses state sharing techniques to allow quicker communication between JS and C++ whether the async event callbacks need to be called.
11 years ago
v8::Local<v8::Value> val = context.As<v8::Value>();
env()->async_listener_unload_function()->Call(process, 1, &val);
asyncwrap: add missing TryCatch The TryCatch was not being checked after calling the unload asyncQueue callback in AsyncWrap::MakeCallback.
11 years ago
if (try_catch.HasCaught())
return v8::Undefined(env()->isolate());
node: add AsyncListener support AsyncListener is a JS API that works in tandem with the AsyncWrap class to allow the user to be alerted to key events in the life cycle of an asynchronous event. The AsyncWrap class has its own MakeCallback implementation that core will be migrated to use, and uses state sharing techniques to allow quicker communication between JS and C++ whether the async event callbacks need to be called.
11 years ago
}
Environment::TickInfo* tick_info = env()->tick_info();
if (tick_info->in_tick()) {
return ret;
}
if (tick_info->length() == 0) {
tick_info->set_index(0);
return ret;
}
tick_info->set_in_tick(true);
env()->tick_callback_function()->Call(process, 0, NULL);
tick_info->set_in_tick(false);
if (try_catch.HasCaught()) {
tick_info->set_last_threw(true);
return Undefined(env()->isolate());
}
return ret;
}
inline v8::Handle<v8::Value> AsyncWrap::MakeCallback(
const v8::Handle<v8::String> symbol,
int argc,
v8::Handle<v8::Value>* argv) {
v8::Local<v8::Value> cb_v = object()->Get(symbol);
v8::Local<v8::Function> cb = cb_v.As<v8::Function>();
assert(cb->IsFunction());
return MakeCallback(cb, argc, argv);
}
inline v8::Handle<v8::Value> AsyncWrap::MakeCallback(
uint32_t index,
int argc,
v8::Handle<v8::Value>* argv) {
v8::Local<v8::Value> cb_v = object()->Get(index);
v8::Local<v8::Function> cb = cb_v.As<v8::Function>();
assert(cb->IsFunction());
return MakeCallback(cb, argc, argv);
}
} // namespace node
#endif // SRC_ASYNC_WRAP_INL_H_