← Back to branch summary

~yolanda.robla/ubuntu/trusty/nodejs/add_distribution

« back to all changes in this revision

Viewing changes to src/node_stat_watcher.cc

  • Committer: Package Import Robot
  • Author(s): Jérémy Lal
  • Date: 2013-08-14 00:16:46 UTC
  • mfrom: (7.1.40 sid)
  • Revision ID: package-import@ubuntu.com-20130814001646-bzlysfh8sd6mukbo
Tags: 0.10.15~dfsg1-4
* Update 2005 patch, adding a handful of tests that can fail on
  slow platforms.
* Add 1004 patch to fix test failures when writing NaN to buffer
  on mipsel.

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/node_stat_watcher.cc
19
19
// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
20
20
// USE OR OTHER DEALINGS IN THE SOFTWARE.
21
21
 
22
 
#include <node_stat_watcher.h>
 
22
#include "node_stat_watcher.h"
23
23
 
24
24
#include <assert.h>
25
25
#include <string.h>
30
30
using namespace v8;
31
31
 
32
32
Persistent<FunctionTemplate> StatWatcher::constructor_template;
 
33
static Persistent<String> onchange_sym;
 
34
static Persistent<String> onstop_sym;
 
35
 
33
36
 
34
37
void StatWatcher::Initialize(Handle<Object> target) {
35
38
  HandleScope scope;
46
49
}
47
50
 
48
51
 
49
 
void StatWatcher::Callback(EV_P_ ev_stat *watcher, int revents) {
50
 
  assert(revents == EV_STAT);
51
 
  StatWatcher *handler = static_cast<StatWatcher*>(watcher->data);
52
 
  assert(watcher == &handler->watcher_);
 
52
static void Delete(uv_handle_t* handle) {
 
53
  delete reinterpret_cast<uv_fs_poll_t*>(handle);
 
54
}
 
55
 
 
56
 
 
57
StatWatcher::StatWatcher()
 
58
  : ObjectWrap()
 
59
  , watcher_(new uv_fs_poll_t)
 
60
{
 
61
  uv_fs_poll_init(uv_default_loop(), watcher_);
 
62
  watcher_->data = static_cast<void*>(this);
 
63
}
 
64
 
 
65
 
 
66
StatWatcher::~StatWatcher() {
 
67
  Stop();
 
68
  uv_close(reinterpret_cast<uv_handle_t*>(watcher_), Delete);
 
69
}
 
70
 
 
71
 
 
72
void StatWatcher::Callback(uv_fs_poll_t* handle,
 
73
                           int status,
 
74
                           const uv_statbuf_t* prev,
 
75
                           const uv_statbuf_t* curr) {
 
76
  StatWatcher* wrap = static_cast<StatWatcher*>(handle->data);
 
77
  assert(wrap->watcher_ == handle);
53
78
  HandleScope scope;
54
 
  Handle<Value> argv[2];
55
 
  argv[0] = Handle<Value>(BuildStatsObject(&watcher->attr));
56
 
  argv[1] = Handle<Value>(BuildStatsObject(&watcher->prev));
57
 
  MakeCallback(handler->handle_, "onchange", 2, argv);
 
79
  Local<Value> argv[3];
 
80
  argv[0] = BuildStatsObject(curr);
 
81
  argv[1] = BuildStatsObject(prev);
 
82
  argv[2] = Integer::New(status);
 
83
  if (status == -1) {
 
84
    SetErrno(uv_last_error(wrap->watcher_->loop));
 
85
  }
 
86
  if (onchange_sym.IsEmpty()) {
 
87
    onchange_sym = NODE_PSYMBOL("onchange");
 
88
  }
 
89
  MakeCallback(wrap->handle_, onchange_sym, ARRAY_SIZE(argv), argv);
58
90
}
59
91
 
60
92
 
61
93
Handle<Value> StatWatcher::New(const Arguments& args) {
62
 
  if (!args.IsConstructCall()) {
63
 
    return FromConstructorTemplate(constructor_template, args);
64
 
  }
65
 
 
 
94
  assert(args.IsConstructCall());
66
95
  HandleScope scope;
67
 
  StatWatcher *s = new StatWatcher();
 
96
  StatWatcher* s = new StatWatcher();
68
97
  s->Wrap(args.Holder());
69
98
  return args.This();
70
99
}
71
100
 
72
101
 
73
102
Handle<Value> StatWatcher::Start(const Arguments& args) {
 
103
  assert(args.Length() == 3);
74
104
  HandleScope scope;
75
105
 
76
 
  if (args.Length() < 1 || !args[0]->IsString()) {
77
 
    return ThrowException(Exception::TypeError(String::New("Bad arguments")));
78
 
  }
79
 
 
80
 
  StatWatcher *handler = ObjectWrap::Unwrap<StatWatcher>(args.Holder());
81
 
  String::Utf8Value path(args[0]->ToString());
82
 
 
83
 
  assert(handler->path_ == NULL);
84
 
  handler->path_ = strdup(*path);
85
 
 
86
 
  ev_tstamp interval = 0.;
87
 
  if (args[2]->IsInt32()) {
88
 
    interval = NODE_V8_UNIXTIME(args[2]);
89
 
  }
90
 
 
91
 
  ev_stat_set(&handler->watcher_, handler->path_, interval);
92
 
  ev_stat_start(EV_DEFAULT_UC_ &handler->watcher_);
93
 
 
94
 
  handler->persistent_ = args[1]->IsTrue();
95
 
 
96
 
  if (!handler->persistent_) {
97
 
    ev_unref(EV_DEFAULT_UC);
98
 
  }
99
 
 
100
 
  handler->Ref();
 
106
  StatWatcher* wrap = ObjectWrap::Unwrap<StatWatcher>(args.Holder());
 
107
  String::Utf8Value path(args[0]);
 
108
  const bool persistent = args[1]->BooleanValue();
 
109
  const uint32_t interval = args[2]->Uint32Value();
 
110
 
 
111
  if (!persistent) uv_unref(reinterpret_cast<uv_handle_t*>(wrap->watcher_));
 
112
  uv_fs_poll_start(wrap->watcher_, Callback, *path, interval);
 
113
  wrap->Ref();
101
114
 
102
115
  return Undefined();
103
116
}
105
118
 
106
119
Handle<Value> StatWatcher::Stop(const Arguments& args) {
107
120
  HandleScope scope;
108
 
  StatWatcher *handler = ObjectWrap::Unwrap<StatWatcher>(args.Holder());
109
 
  MakeCallback(handler->handle_, "onstop", 0, NULL);
110
 
  handler->Stop();
 
121
  StatWatcher* wrap = ObjectWrap::Unwrap<StatWatcher>(args.Holder());
 
122
  if (onstop_sym.IsEmpty()) {
 
123
    onstop_sym = NODE_PSYMBOL("onstop");
 
124
  }
 
125
  MakeCallback(wrap->handle_, onstop_sym, 0, NULL);
 
126
  wrap->Stop();
111
127
  return Undefined();
112
128
}
113
129
 
114
130
 
115
131
void StatWatcher::Stop () {
116
 
  if (watcher_.active) {
117
 
    if (!persistent_) ev_ref(EV_DEFAULT_UC);
118
 
    ev_stat_stop(EV_DEFAULT_UC_ &watcher_);
119
 
    free(path_);
120
 
    path_ = NULL;
121
 
    Unref();
122
 
  }
 
132
  if (!uv_is_active(reinterpret_cast<uv_handle_t*>(watcher_))) return;
 
133
  uv_fs_poll_stop(watcher_);
 
134
  Unref();
123
135
}
124
136
 
125
137