daohualiuxiang
/
node
mirror of https://github.com/nodejs/node.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Remove net_legacy timers_legacy

pull/22966/head
Ryan Dahl 2011-10-11 13:07:14 -07:00
parent d2b8037ed0
commit be0bb2dc13
13 changed files with 2 additions and 3544 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

0
lib/net_uv.js → lib/net.js
View File

1215
lib/net_legacy.js
View File

File diff suppressed because it is too large Load Diff

0
lib/timers_uv.js → lib/timers.js
View File

224
lib/timers_legacy.js
View File

@ -1,224 +0,0 @@
// 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.
var Timer = process.binding('timer').Timer;
var L = require('_linklist');
var assert = require('assert').ok;
var debug;
if (process.env.NODE_DEBUG && /timer/.test(process.env.NODE_DEBUG)) {
debug = function() { require('util').error.apply(this, arguments); };
} else {
debug = function() { };
}
// IDLE TIMEOUTS
//
// Because often many sockets will have the same idle timeout we will not
// use one timeout watcher per item. It is too much overhead. Instead
// we'll use a single watcher for all sockets with the same timeout value
// and a linked list. This technique is described in the libev manual:
// http://pod.tst.eu/http://cvs.schmorp.de/libev/ev.pod#Be_smart_about_timeouts
// Object containing all lists, timers
// key = time in milliseconds
// value = list
var lists = {};
// the main function - creates lists on demand and the watchers associated
// with them.
function insert(item, msecs) {
item._idleStart = new Date();
item._idleTimeout = msecs;
if (msecs < 0) return;
var list;
if (lists[msecs]) {
list = lists[msecs];
} else {
list = new Timer();
L.init(list);
lists[msecs] = list;
list.callback = function() {
debug('timeout callback ' + msecs);
// TODO - don't stop and start the watcher all the time.
// just set its repeat
var now = new Date();
debug('now: ' + now);
var first;
while (first = L.peek(list)) {
var diff = now - first._idleStart;
if (diff + 1 < msecs) {
list.again(msecs - diff);
debug(msecs + ' list wait because diff is ' + diff);
return;
} else {
L.remove(first);
assert(first !== L.peek(list));
if (first._onTimeout) first._onTimeout();
}
}
debug(msecs + ' list empty');
assert(L.isEmpty(list));
list.stop();
};
}
if (L.isEmpty(list)) {
// if empty (re)start the timer
list.again(msecs);
}
L.append(list, item);
assert(!L.isEmpty(list)); // list is not empty
}
var unenroll = exports.unenroll = function(item) {
L.remove(item);
var list = lists[item._idleTimeout];
// if empty then stop the watcher
debug('unenroll');
if (list && L.isEmpty(list)) {
debug('unenroll: list empty');
list.stop();
}
};
// Does not start the time, just sets up the members needed.
exports.enroll = function(item, msecs) {
// if this item was already in a list somewhere
// then we should unenroll it from that
if (item._idleNext) unenroll(item);
item._idleTimeout = msecs;
L.init(item);
};
// call this whenever the item is active (not idle)
// it will reset its timeout.
exports.active = function(item) {
var msecs = item._idleTimeout;
if (msecs >= 0) {
var list = lists[msecs];
if (item._idleNext == item) {
insert(item, msecs);
} else {
item._idleStart = new Date();
L.append(list, item);
}
}
};
/*
* DOM-style timers
*/
exports.setTimeout = function(callback, after) {
var timer;
if (after <= 0) {
// Use the slow case for after == 0
timer = new Timer();
timer.callback = callback;
} else {
timer = { _idleTimeout: after, _onTimeout: callback };
timer._idlePrev = timer;
timer._idleNext = timer;
}
/*
* Sometimes setTimeout is called with arguments, EG
*
* setTimeout(callback, 2000, "hello", "world")
*
* If that's the case we need to call the callback with
* those args. The overhead of an extra closure is not
* desired in the normal case.
*/
if (arguments.length > 2) {
var args = Array.prototype.slice.call(arguments, 2);
var c = function() {
callback.apply(timer, args);
};
if (timer instanceof Timer) {
timer.callback = c;
} else {
timer._onTimeout = c;
}
}
if (timer instanceof Timer) {
timer.start(0, 0);
} else {
exports.active(timer);
}
return timer;
};
exports.clearTimeout = function(timer) {
if (timer && (timer.callback || timer._onTimeout)) {
timer.callback = timer._onTimeout = null;
exports.unenroll(timer);
if (timer instanceof Timer) timer.stop(); // for after === 0
}
};
exports.setInterval = function(callback, repeat) {
var timer = new Timer();
if (arguments.length > 2) {
var args = Array.prototype.slice.call(arguments, 2);
timer.callback = function() {
callback.apply(timer, args);
};
} else {
timer.callback = callback;
}
timer.start(repeat, repeat ? repeat : 1);
return timer;
};
exports.clearInterval = function(timer) {
if (timer instanceof Timer) {
timer.callback = null;
timer.stop();
}
};

9
node.gyp
View File

@ -30,8 +30,7 @@
'lib/http.js',
'lib/https.js',
'lib/module.js',
'lib/net_legacy.js',
'lib/net_uv.js',
'lib/net.js',
'lib/os.js',
'lib/path.js',
'lib/punycode.js',
@ -41,8 +40,7 @@
'lib/stream.js',
'lib/string_decoder.js',
'lib/sys.js',
'lib/timers_legacy.js',
'lib/timers_uv.js',
'lib/timers.js',
'lib/tls.js',
'lib/tty_legacy.js',
'lib/tty_posix.js',
@ -112,7 +110,6 @@
'src/node_file.h',
'src/node_http_parser.h',
'src/node_javascript.h',
'src/node_net.h',
'src/node_os.h',
'src/node_root_certs.h',
'src/node_script.h',
@ -174,13 +171,11 @@
'defines': [ '__POSIX__' ],
'sources': [
'src/node_cares.cc',
'src/node_net.cc',
'src/node_signal_watcher.cc',
'src/node_stat_watcher.cc',
'src/node_io_watcher.cc',
'src/node_stdio.cc',
'src/node_child_process.cc',
'src/node_timer.cc'
]
}],
[ 'OS=="mac"', {

9
src/node.cc
View File

@ -77,14 +77,12 @@ extern "C" {
#ifdef __POSIX__
# include <node_io_watcher.h>
#endif
#include <node_net.h>
#include <node_cares.h>
#include <node_file.h>
#include <node_http_parser.h>
#ifdef __POSIX__
# include <node_signal_watcher.h>
# include <node_stat_watcher.h>
# include <node_timer.h>
#endif
#if !defined(_MSC_VER)
#include <node_child_process.h>
@ -1902,13 +1900,6 @@ static Handle<Value> Binding(const Arguments& args) {
binding_cache->Set(module, exports);
#endif
} else if (!strcmp(*module_v, "timer")) {
#ifdef __POSIX__
exports = Object::New();
Timer::Initialize(exports);
binding_cache->Set(module, exports);
#endif
} else if (!strcmp(*module_v, "natives")) {
exports = Object::New();
DefineJavaScript(exports);

6
src/node.js
View File

@ -458,9 +458,6 @@
// backend.
function translateId(id) {
switch (id) {
case 'net':
return process.features.uv ? 'net_uv' : 'net_legacy';
case 'tty':
return process.features.uv ? 'tty_uv' : 'tty_legacy';
@ -468,9 +465,6 @@
return process.features.uv ? 'child_process_uv' :
'child_process_legacy';
case 'timers':
return process.features.uv ? 'timers_uv' : 'timers_legacy';
case 'dgram':
return process.features.uv ? 'dgram_uv' : 'dgram_legacy';

3
src/node_extensions.h
View File

@ -31,9 +31,6 @@ NODE_EXT_LIST_ITEM(node_crypto)
#endif
NODE_EXT_LIST_ITEM(node_evals)
NODE_EXT_LIST_ITEM(node_fs)
#ifdef __POSIX__
NODE_EXT_LIST_ITEM(node_net)
#endif
NODE_EXT_LIST_ITEM(node_http_parser)
#ifdef __POSIX__
NODE_EXT_LIST_ITEM(node_signal_watcher)

1781
src/node_net.cc
View File

File diff suppressed because it is too large Load Diff

33
src/node_net.h
View File

@ -1,33 +0,0 @@
// 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 NODE_NET
#define NODE_NET
#include <v8.h>
namespace node {
void InitNet(v8::Handle<v8::Object> target);
}
#endif // NODE_NET

200
src/node_timer.cc
View File

@ -1,200 +0,0 @@
// 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.
#include <node.h>
#include <node_timer.h>
#include <assert.h>
namespace node {
using namespace v8;
Persistent<FunctionTemplate> Timer::constructor_template;
static Persistent<String> timeout_symbol;
static Persistent<String> repeat_symbol;
static Persistent<String> callback_symbol;
void Timer::Initialize(Handle<Object> target) {
HandleScope scope;
Local<FunctionTemplate> t = FunctionTemplate::New(Timer::New);
constructor_template = Persistent<FunctionTemplate>::New(t);
constructor_template->InstanceTemplate()->SetInternalFieldCount(1);
constructor_template->SetClassName(String::NewSymbol("Timer"));
timeout_symbol = NODE_PSYMBOL("timeout");
repeat_symbol = NODE_PSYMBOL("repeat");
callback_symbol = NODE_PSYMBOL("callback");
NODE_SET_PROTOTYPE_METHOD(constructor_template, "start", Timer::Start);
NODE_SET_PROTOTYPE_METHOD(constructor_template, "stop", Timer::Stop);
NODE_SET_PROTOTYPE_METHOD(constructor_template, "again", Timer::Again);
constructor_template->InstanceTemplate()->SetAccessor(repeat_symbol,
RepeatGetter, RepeatSetter);
target->Set(String::NewSymbol("Timer"), constructor_template->GetFunction());
}
Handle<Value> Timer::RepeatGetter(Local<String> property,
const AccessorInfo& info) {
HandleScope scope;
Timer *timer = ObjectWrap::Unwrap<Timer>(info.This());
assert(timer);
assert(property == repeat_symbol);
Local<Integer> v = Integer::New(timer->watcher_.repeat);
return scope.Close(v);
}
void Timer::RepeatSetter(Local<String> property,
Local<Value> value,
const AccessorInfo& info) {
HandleScope scope;
Timer *timer = ObjectWrap::Unwrap<Timer>(info.This());
assert(timer);
assert(property == repeat_symbol);
timer->watcher_.repeat = NODE_V8_UNIXTIME(value);
}
void Timer::OnTimeout(EV_P_ ev_timer *watcher, int revents) {
Timer *timer = static_cast<Timer*>(watcher->data);
assert(revents == EV_TIMEOUT);
HandleScope scope;
Local<Value> callback_v = timer->handle_->Get(callback_symbol);
if (!callback_v->IsFunction()) {
timer->Stop();
return;
}
Local<Function> callback = Local<Function>::Cast(callback_v);
TryCatch try_catch;
callback->Call(timer->handle_, 0, NULL);
if (try_catch.HasCaught()) {
FatalException(try_catch);
}
if (timer->watcher_.repeat == 0) timer->Unref();
}
Timer::~Timer() {
ev_timer_stop(EV_DEFAULT_UC_ &watcher_);
}
Handle<Value> Timer::New(const Arguments& args) {
if (!args.IsConstructCall()) {
return FromConstructorTemplate(constructor_template, args);
}
HandleScope scope;
Timer *t = new Timer();
t->Wrap(args.Holder());
return args.This();
}
Handle<Value> Timer::Start(const Arguments& args) {
HandleScope scope;
Timer *timer = ObjectWrap::Unwrap<Timer>(args.Holder());
if (args.Length() != 2)
return ThrowException(String::New("Bad arguments"));
bool was_active = ev_is_active(&timer->watcher_);
ev_tstamp after = NODE_V8_UNIXTIME(args[0]);
ev_tstamp repeat = NODE_V8_UNIXTIME(args[1]);
ev_timer_init(&timer->watcher_, Timer::OnTimeout, after, repeat);
timer->watcher_.data = timer;
// Update the event loop time. Need to call this because processing JS can
// take non-negligible amounts of time.
ev_now_update(EV_DEFAULT_UC);
ev_timer_start(EV_DEFAULT_UC_ &timer->watcher_);
if (!was_active) timer->Ref();
return Undefined();
}
Handle<Value> Timer::Stop(const Arguments& args) {
HandleScope scope;
Timer *timer = ObjectWrap::Unwrap<Timer>(args.Holder());
timer->Stop();
return Undefined();
}
void Timer::Stop() {
if (watcher_.active) {
ev_timer_stop(EV_DEFAULT_UC_ &watcher_);
Unref();
}
}
Handle<Value> Timer::Again(const Arguments& args) {
HandleScope scope;
Timer *timer = ObjectWrap::Unwrap<Timer>(args.Holder());
int was_active = ev_is_active(&timer->watcher_);
if (args.Length() > 0) {
ev_tstamp repeat = NODE_V8_UNIXTIME(args[0]);
if (repeat > 0) timer->watcher_.repeat = repeat;
}
ev_timer_again(EV_DEFAULT_UC_ &timer->watcher_);
// ev_timer_again can start or stop the watcher.
// So we need to check what happened and adjust the ref count
// appropriately.
if (ev_is_active(&timer->watcher_)) {
if (!was_active) timer->Ref();
} else {
if (was_active) timer->Unref();
}
return Undefined();
}
} // namespace node

64
src/node_timer.h
View File

@ -1,64 +0,0 @@
// 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_NODE_TIMER_H_
#define SRC_NODE_TIMER_H_
#include <node.h>
#include <node_object_wrap.h>
#include <v8.h>
#include <uv-private/ev.h>
namespace node {
class Timer : ObjectWrap {
public:
static void Initialize(v8::Handle<v8::Object> target);
protected:
static v8::Persistent<v8::FunctionTemplate> constructor_template;
Timer() : ObjectWrap() {
// dummy timeout values
ev_timer_init(&watcher_, OnTimeout, 0., 1.);
watcher_.data = this;
}
~Timer();
static v8::Handle<v8::Value> New(const v8::Arguments& args);
static v8::Handle<v8::Value> Start(const v8::Arguments& args);
static v8::Handle<v8::Value> Stop(const v8::Arguments& args);
static v8::Handle<v8::Value> Again(const v8::Arguments& args);
static v8::Handle<v8::Value> RepeatGetter(v8::Local<v8::String> property,
const v8::AccessorInfo& info);
static void RepeatSetter(v8::Local<v8::String> property,
v8::Local<v8::Value> value,
const v8::AccessorInfo& info);
private:
static void OnTimeout(EV_P_ ev_timer *watcher, int revents);
void Stop();
ev_timer watcher_;
};
} // namespace node
#endif // SRC_NODE_TIMER_H_

2
wscript
View File

@ -903,13 +903,11 @@ def build(bld):
node.source += " src/node_stdio_win32.cc "
else:
node.source += " src/node_cares.cc "
node.source += " src/node_net.cc "
node.source += " src/node_signal_watcher.cc "
node.source += " src/node_stat_watcher.cc "
node.source += " src/node_io_watcher.cc "
node.source += " src/node_stdio.cc "
node.source += " src/node_child_process.cc "
node.source += " src/node_timer.cc "
node.source += bld.env["PLATFORM_FILE"]
if not product_type_is_lib: