mirror of https://github.com/lukechilds/node.git
Ryan Dahl
13 years ago
13 changed files with 2 additions and 3544 deletions
File diff suppressed because it is too large
@ -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(); |
|||
} |
|||
}; |
|||
File diff suppressed because it is too large
@ -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
|
|||
@ -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
|
|||
@ -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_
|
|||
Loading…
Reference in new issue