lukechilds
/
node
mirror of https://github.com/lukechilds/node.git
1
0
Fork 0
Code Issues Projects Releases Wiki Activity
Browse Source

Revert "handle_wrap: IsRefed -> Unrefed, no isAlive check" 

This reverts commit 9bb5a5e2a1.

This API is not suitable because it depended on being able to
potentially access the handle's flag after the handle was already
cleaned up. Since this is not actually possible (obviously, oops)
this newer API no longer makes much sense, and the older API is more
suitable.

API comparison:
IsRefed -> Has a strong reference AND is alive. (Deterministic)
Unrefed -> Has a weak reference OR is dead. (Less deterministic)

Refs: https://github.com/nodejs/node/pull/6395
Refs: https://github.com/nodejs/node/pull/6204
Refs: https://github.com/nodejs/node/pull/6401
Refs: https://github.com/nodejs/node/pull/6382
Fixes: https://github.com/nodejs/node/pull/6381

PR-URL: https://github.com/nodejs/node/pull/6546
Reviewed-By: James M Snell <jasnell@gmail.com>
Reviewed-By: Ben Noordhuis <info@bnoordhuis.nl>
Reviewed-By: Trevor Norris <trev.norris@gmail.com>

Conflicts:
	src/handle_wrap.cc
	test/parallel/test-handle-wrap-isrefed-tty.js
	test/parallel/test-handle-wrap-isrefed.js
process-exit-stdio-flushing
Jeremiah Senkpiel 9 years ago
parent
738a1d639f
commit
96a9439fd2
11 changed files with 50 additions and 63 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Split View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 4
      src/handle_wrap.cc
  2. 2
      src/handle_wrap.h
  3. 2
      src/pipe_wrap.cc
  4. 2
      src/process_wrap.cc
  5. 2
      src/signal_wrap.cc
  6. 2
      src/tcp_wrap.cc
  7. 2
      src/timer_wrap.cc
  8. 2
      src/tty_wrap.cc
  9. 2
      src/udp_wrap.cc
  10. 13
      test/parallel/test-handle-wrap-isrefed-tty.js
  11. 80
      test/parallel/test-handle-wrap-isrefed.js

4
src/handle_wrap.cc
View File

@ -33,9 +33,9 @@ void HandleWrap::Unref(const FunctionCallbackInfo<Value>& args) {
}
void HandleWrap::Unrefed(const FunctionCallbackInfo<Value>& args) {
void HandleWrap::IsRefed(const FunctionCallbackInfo<Value>& args) {
HandleWrap* wrap = Unwrap<HandleWrap>(args.Holder());
args.GetReturnValue().Set(!HasRef(wrap));
args.GetReturnValue().Set(HasRef(wrap));
}

2
src/handle_wrap.h
View File

@ -35,7 +35,7 @@ class HandleWrap : public AsyncWrap {
static void Close(const v8::FunctionCallbackInfo<v8::Value>& args);
static void Ref(const v8::FunctionCallbackInfo<v8::Value>& args);
static void Unref(const v8::FunctionCallbackInfo<v8::Value>& args);
static void Unrefed(const v8::FunctionCallbackInfo<v8::Value>& args);
static void IsRefed(const v8::FunctionCallbackInfo<v8::Value>& args);
static inline bool IsAlive(const HandleWrap* wrap) {
return wrap != nullptr && wrap->state_ != kClosed;

2
src/pipe_wrap.cc
View File

@ -80,7 +80,7 @@ void PipeWrap::Initialize(Local<Object> target,
env->SetProtoMethod(t, "close", HandleWrap::Close);
env->SetProtoMethod(t, "unref", HandleWrap::Unref);
env->SetProtoMethod(t, "ref", HandleWrap::Ref);
env->SetProtoMethod(t, "unrefed", HandleWrap::Unrefed);
env->SetProtoMethod(t, "isRefed", HandleWrap::IsRefed);
StreamWrap::AddMethods(env, t);

2
src/process_wrap.cc
View File

@ -40,7 +40,7 @@ class ProcessWrap : public HandleWrap {
env->SetProtoMethod(constructor, "ref", HandleWrap::Ref);
env->SetProtoMethod(constructor, "unref", HandleWrap::Unref);
env->SetProtoMethod(constructor, "unrefed", HandleWrap::Unrefed);
env->SetProtoMethod(constructor, "isRefed", HandleWrap::IsRefed);
target->Set(FIXED_ONE_BYTE_STRING(env->isolate(), "Process"),
constructor->GetFunction());

2
src/signal_wrap.cc
View File

@ -32,7 +32,7 @@ class SignalWrap : public HandleWrap {
env->SetProtoMethod(constructor, "close", HandleWrap::Close);
env->SetProtoMethod(constructor, "ref", HandleWrap::Ref);
env->SetProtoMethod(constructor, "unref", HandleWrap::Unref);
env->SetProtoMethod(constructor, "unrefed", HandleWrap::Unrefed);
env->SetProtoMethod(constructor, "isRefed", HandleWrap::IsRefed);
env->SetProtoMethod(constructor, "start", Start);
env->SetProtoMethod(constructor, "stop", Stop);

2
src/tcp_wrap.cc
View File

@ -87,7 +87,7 @@ void TCPWrap::Initialize(Local<Object> target,
env->SetProtoMethod(t, "ref", HandleWrap::Ref);
env->SetProtoMethod(t, "unref", HandleWrap::Unref);
env->SetProtoMethod(t, "unrefed", HandleWrap::Unrefed);
env->SetProtoMethod(t, "isRefed", HandleWrap::IsRefed);
StreamWrap::AddMethods(env, t, StreamBase::kFlagHasWritev);

2
src/timer_wrap.cc
View File

@ -39,7 +39,7 @@ class TimerWrap : public HandleWrap {
env->SetProtoMethod(constructor, "close", HandleWrap::Close);
env->SetProtoMethod(constructor, "ref", HandleWrap::Ref);
env->SetProtoMethod(constructor, "unref", HandleWrap::Unref);
env->SetProtoMethod(constructor, "unrefed", HandleWrap::Unrefed);
env->SetProtoMethod(constructor, "isRefed", HandleWrap::IsRefed);
env->SetProtoMethod(constructor, "start", Start);
env->SetProtoMethod(constructor, "stop", Stop);

2
src/tty_wrap.cc
View File

@ -36,7 +36,7 @@ void TTYWrap::Initialize(Local<Object> target,
env->SetProtoMethod(t, "close", HandleWrap::Close);
env->SetProtoMethod(t, "unref", HandleWrap::Unref);
env->SetProtoMethod(t, "unrefed", HandleWrap::Unrefed);
env->SetProtoMethod(t, "isRefed", HandleWrap::IsRefed);
StreamWrap::AddMethods(env, t, StreamBase::kFlagNoShutdown);

2
src/udp_wrap.cc
View File

@ -108,7 +108,7 @@ void UDPWrap::Initialize(Local<Object> target,
env->SetProtoMethod(t, "ref", HandleWrap::Ref);
env->SetProtoMethod(t, "unref", HandleWrap::Unref);
env->SetProtoMethod(t, "unrefed", HandleWrap::Unrefed);
env->SetProtoMethod(t, "isRefed", HandleWrap::IsRefed);
target->Set(FIXED_ONE_BYTE_STRING(env->isolate(), "UDP"), t->GetFunction());
env->set_udp_constructor_function(t->GetFunction());

13
test/parallel/test-handle-wrap-isrefed-tty.js
View File

@ -9,19 +9,18 @@ function makeAssert(message) {
strictEqual(actual, expected, message);
};
}
const assert = makeAssert('unrefed() not working on tty_wrap');
const assert = makeAssert('isRefed() not working on tty_wrap');
if (process.argv[2] === 'child') {
// Test tty_wrap in piped child to guarentee stdin being a TTY.
const ReadStream = require('tty').ReadStream;
const tty = new ReadStream(0);
assert(Object.getPrototypeOf(tty._handle).hasOwnProperty('unrefed'), true);
assert(tty._handle.unrefed(), false);
assert(Object.getPrototypeOf(tty._handle).hasOwnProperty('isRefed'), true);
assert(tty._handle.isRefed(), true);
tty.unref();
assert(tty._handle.unrefed(), true);
tty._handle.close(common.mustCall(() => assert(tty._handle.unrefed(), true)));
tty._handle.close(common.fail);
assert(tty._handle.unrefed(), true);
assert(tty._handle.isRefed(), false);
tty._handle.close(
common.mustCall(() => assert(tty._handle.isRefed(), false)));
return;
}

80
test/parallel/test-handle-wrap-isrefed.js
View File

@ -12,102 +12,90 @@ function makeAssert(message) {
// child_process
{
const assert = makeAssert('unrefed() not working on process_wrap');
const assert = makeAssert('isRefed() not working on process_wrap');
const spawn = require('child_process').spawn;
const cmd = common.isWindows ? 'rundll32' : 'ls';
const cp = spawn(cmd);
assert(Object.getPrototypeOf(cp._handle).hasOwnProperty('unrefed'), true);
assert(cp._handle.unrefed(), false);
assert(Object.getPrototypeOf(cp._handle).hasOwnProperty('isRefed'), true);
assert(cp._handle.isRefed(), true);
cp.unref();
assert(cp._handle.unrefed(), true);
assert(cp._handle.isRefed(), false);
cp.ref();
assert(cp._handle.unrefed(), false);
cp._handle.close(common.mustCall(() => assert(cp._handle.unrefed(), true)));
cp._handle.close(common.fail);
assert(cp._handle.unrefed(), false);
assert(cp._handle.isRefed(), true);
cp._handle.close(common.mustCall(() => assert(cp._handle.isRefed(), false)));
}
// dgram
{
const assert = makeAssert('unrefed() not working on udp_wrap');
const assert = makeAssert('isRefed() not working on udp_wrap');
const dgram = require('dgram');
const sock4 = dgram.createSocket('udp4');
assert(Object.getPrototypeOf(sock4._handle).hasOwnProperty('unrefed'), true);
assert(sock4._handle.unrefed(), false);
assert(Object.getPrototypeOf(sock4._handle).hasOwnProperty('isRefed'), true);
assert(sock4._handle.isRefed(), true);
sock4.unref();
assert(sock4._handle.unrefed(), true);
assert(sock4._handle.isRefed(), false);
sock4.ref();
assert(sock4._handle.unrefed(), false);
assert(sock4._handle.isRefed(), true);
sock4._handle.close(
common.mustCall(() => assert(sock4._handle.unrefed(), true)));
sock4._handle.close(common.fail);
assert(sock4._handle.unrefed(), false);
common.mustCall(() => assert(sock4._handle.isRefed(), false)));
const sock6 = dgram.createSocket('udp6');
assert(Object.getPrototypeOf(sock6._handle).hasOwnProperty('unrefed'), true);
assert(sock6._handle.unrefed(), false);
assert(Object.getPrototypeOf(sock6._handle).hasOwnProperty('isRefed'), true);
assert(sock6._handle.isRefed(), true);
sock6.unref();
assert(sock6._handle.unrefed(), true);
assert(sock6._handle.isRefed(), false);
sock6.ref();
assert(sock6._handle.unrefed(), false);
assert(sock6._handle.isRefed(), true);
sock6._handle.close(
common.mustCall(() => assert(sock6._handle.unrefed(), true)));
sock6._handle.close(common.fail);
assert(sock6._handle.unrefed(), false);
common.mustCall(() => assert(sock6._handle.isRefed(), false)));
}
// pipe
{
const assert = makeAssert('unrefed() not working on pipe_wrap');
const assert = makeAssert('isRefed() not working on pipe_wrap');
const Pipe = process.binding('pipe_wrap').Pipe;
const handle = new Pipe();
assert(Object.getPrototypeOf(handle).hasOwnProperty('unrefed'), true);
assert(handle.unrefed(), false);
assert(Object.getPrototypeOf(handle).hasOwnProperty('isRefed'), true);
assert(handle.isRefed(), true);
handle.unref();
assert(handle.unrefed(), true);
assert(handle.isRefed(), false);
handle.ref();
assert(handle.unrefed(), false);
handle.close(common.mustCall(() => assert(handle.unrefed(), true)));
handle.close(common.fail);
assert(handle.unrefed(), false);
assert(handle.isRefed(), true);
handle.close(common.mustCall(() => assert(handle.isRefed(), false)));
}
// tcp
{
const assert = makeAssert('unrefed() not working on tcp_wrap');
const assert = makeAssert('isRefed() not working on tcp_wrap');
const net = require('net');
const server = net.createServer(() => {}).listen(common.PORT);
assert(Object.getPrototypeOf(server._handle).hasOwnProperty('unrefed'), true);
assert(server._handle.unrefed(), false);
assert(Object.getPrototypeOf(server._handle).hasOwnProperty('isRefed'), true);
assert(server._handle.isRefed(), true);
assert(server._unref, false);
server.unref();
assert(server._handle.unrefed(), true);
assert(server._handle.isRefed(), false);
assert(server._unref, true);
server.ref();
assert(server._handle.unrefed(), false);
assert(server._handle.isRefed(), true);
assert(server._unref, false);
server._handle.close(
common.mustCall(() => assert(server._handle.unrefed(), true)));
server._handle.close(common.fail);
assert(server._handle.unrefed(), false);
common.mustCall(() => assert(server._handle.isRefed(), false)));
}
// timers
{
const assert = makeAssert('unrefed() not working on timer_wrap');
const assert = makeAssert('isRefed() not working on timer_wrap');
const timer = setTimeout(() => {}, 500);
timer.unref();
assert(Object.getPrototypeOf(timer._handle).hasOwnProperty('unrefed'), true);
assert(timer._handle.unrefed(), true);
assert(Object.getPrototypeOf(timer._handle).hasOwnProperty('isRefed'), true);
assert(timer._handle.isRefed(), false);
timer.ref();
assert(timer._handle.unrefed(), false);
assert(timer._handle.isRefed(), true);
timer._handle.close(
common.mustCall(() => assert(timer._handle.unrefed(), true)));
timer._handle.close(common.fail);
assert(timer._handle.unrefed(), false);
common.mustCall(() => assert(timer._handle.isRefed(), false)));
}

Write Preview
Loading…
Cancel
Save