├── .project
├── LICENSE
├── README.md
├── lib
├── cronTrigger.js
├── cronTriggerDecoder.js
├── job.js
├── priorityQueue.js
├── schedule.js
└── simpleTrigger.js
├── node_modules
└── log4js
│ ├── .npmignore
│ ├── .project
│ ├── .travis.yml
│ ├── README.md
│ ├── example-connect-logger.js
│ ├── example-socket.js
│ ├── example.js
│ ├── lib
│ ├── appenders
│ │ ├── console.js
│ │ ├── file.js
│ │ ├── gelf.js
│ │ ├── hookio.js
│ │ ├── logLevelFilter.js
│ │ ├── multiprocess.js
│ │ └── smtp.js
│ ├── connect-logger.js
│ ├── date_format.js
│ ├── layouts.js
│ ├── levels.js
│ ├── log4js.js
│ ├── log4js.json
│ └── streams.js
│ ├── log-rolling.js
│ ├── memory-test.js
│ ├── node_modules
│ ├── async
│ │ ├── .gitmodules
│ │ ├── LICENSE
│ │ ├── Makefile
│ │ ├── README.md
│ │ ├── deps
│ │ │ ├── nodeunit.css
│ │ │ └── nodeunit.js
│ │ ├── dist
│ │ │ └── async.min.js
│ │ ├── index.js
│ │ ├── lib
│ │ │ └── async.js
│ │ ├── nodelint.cfg
│ │ ├── package.json
│ │ └── test
│ │ │ ├── test-async.js
│ │ │ └── test.html
│ └── compress-buffer
│ │ ├── .lock-wscript
│ │ ├── .npmignore
│ │ ├── CHANGELOG
│ │ ├── LICENSE
│ │ ├── Makefile
│ │ ├── README.md
│ │ ├── build
│ │ ├── .wafpickle-7
│ │ ├── Release
│ │ │ ├── compress-buffer-bindings.node
│ │ │ └── src
│ │ │ │ └── compress-buffer_1.o
│ │ ├── c4che
│ │ │ ├── Release.cache.py
│ │ │ └── build.config.py
│ │ └── config.log
│ │ ├── index.js
│ │ ├── package.json
│ │ ├── src
│ │ ├── compress-buffer.cc
│ │ └── compress-buffer.cc-
│ │ ├── t
│ │ ├── t.c
│ │ ├── t.plist
│ │ ├── test.csv
│ │ ├── test.gz
│ │ ├── test
│ │ └── node-compress-buffer-test.js
│ │ └── wscript
│ ├── package.json
│ └── test
│ ├── bufferedStream.js
│ ├── date_format.js
│ ├── fileAppender.js
│ ├── gelfAppender.js
│ ├── hookioAppender.js
│ ├── layouts.js
│ ├── levels.js
│ ├── log4js.json
│ ├── logLevelFilter.js
│ ├── logging.js
│ ├── multiprocessAppender.js
│ ├── rollingFileStream.js
│ ├── smtpAppender.js
│ ├── test-connect-logger.js
│ ├── test-global-log-level.js
│ ├── test-log-abspath.js
│ ├── test-nolog.js
│ ├── test-rolling-file-stream
│ ├── test-rolling-file-stream-write
│ ├── test-rolling-file-stream-write-less
│ ├── test-rolling-file-stream-write-more
│ ├── test-rolling-file-stream-write-more.1
│ ├── with-log-rolling.json
│ └── with-logLevelFilter.json
├── package.json
└── test
├── cronTriggerTest.js
├── priorityQueueTest.js
├── scheduleTest.js
└── test.js
/.project:
--------------------------------------------------------------------------------
1 |
2 |
3 | schedule
4 |
6 |
7 |
8 |
9 |
10 |
11 |
12 |
--------------------------------------------------------------------------------
/LICENSE:
--------------------------------------------------------------------------------
1 | (The MIT License)
2 |
3 | Copyright (c) 2012 Netease, Inc. and other pomelo contributors
4 |
5 | Permission is hereby granted, free of charge, to any person obtaining
6 | a copy of this software and associated documentation files (the
7 | 'Software'), to deal in the Software without restriction, including
8 | without limitation the rights to use, copy, modify, merge, publish,
9 | distribute, sublicense, and/or sell copies of the Software, and to
10 | permit persons to whom the Software is furnished to do so, subject to
11 | the following conditions:
12 |
13 | The above copyright notice and this permission notice shall be
14 | included in all copies or substantial portions of the Software.
15 |
16 | THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND,
17 | EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
18 | MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
19 | IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
20 | CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
21 | TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
22 | SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
23 |
--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
1 | # pomelo-scheduler
2 | pomelo-schedule is a schedule tool for nodejs, it's purpose is to provide a product level schedule module which is high efficient and can support large number job schedule.You can
3 |
4 | As a schedule tool, it support two kinds of trigger: A simple trigger which use a js object and a Cron time trigger which use a Cron time string.
5 | ##Installation
6 | ```
7 | npm install pomelo-schedule
8 | ```
9 | ##Schedule simple Job
10 | Simple job will receive a object as a trigger, which take three attributes, a JS function as object, and an object as the parameters in the job.
11 |
12 | ###Simple trigge example
13 | ``` javascript
14 | //Fire 10000ms after now, and run 10 times with a 1000ms interval.
15 | var trigger1 = {
16 | start : Date.now() + 10000, //Start time, use the time in date object
17 | period : 1000, //Fire interval, the precision is millisecond
18 | count : 10 //Fire times, in this case the trigger will fire 10 times.
19 | }
20 |
21 | //Fire right now, and run 10 times with 1000ms interval.
22 | var trigger2 = {
23 | period : 1000,
24 | count : 10
25 | }
26 |
27 | //Fire right now, and run for ever with 1000ms interval.
28 | var trigger3 = {
29 | period : 1000
30 | }
31 |
32 | //Fire 3000ms after right now, run only once.
33 | var trigger4 = {
34 | start : Date.now() + 3000;
35 | }
36 |
37 | //The job will fire right now, run only once.
38 | var trigger5 = {
39 | }
40 |
41 | //Illegal! The 'count' attribute cannot used alone without 'period'.
42 | var trigger6 = {
43 | count : 10;
44 | }
45 | ```
46 |
47 | ###Simple job example
48 | ``` javascript
49 | var schedule = require('../lib/schedule');
50 |
51 | var simpleJob = function(data){
52 | console.log("run Job :" + data.name);
53 | }
54 |
55 | schedule.scheduleJob({start:Date.now(), period:3000, count: 10}, simpleJob, {name: 'simpleJobExample'});
56 | ```
57 | ##Schedule cron Job
58 | Cron job is the job that use cron trigger, it is just like the simple job, only use the cron trigger instead of simple trigger.
59 |
60 | ###Cron job example
61 | ``` javascript
62 | var schedule = require('../lib/schedule');
63 |
64 | var cronJob = function(data){
65 | console.log("run Job :" + data.name);
66 | }
67 |
68 | schedule.scheduleJob("0 0/15 8 * * *", cronJob, {name:'cronJobExample'});
69 | ```
70 | ###Cron Trigger syntax
71 | Cron trigger has 7 fiels, the format is very like the cronTab in linux, only add a second field in the head. The fields and the boundary is as follow:
72 |
73 | * * * * * * command to be executed
74 | - - - - - -
75 | | | | | | |
76 | | | | | | +----- day of week (0 - 6) (Sunday=0)
77 | | | | | +------- month (1 - 12)
78 | | | | +--------- day of month (1 - 31)
79 | | | +----------- hour (0 - 23)
80 | | +------------- min (0 - 59)
81 | +------------- second (0 - 59)
82 |
83 | ###Exampe of cron tirggers
84 |
85 | "0/2 0 8 * * 6" Fire at every Satuaday at every even seconds of 08:00
86 | "0 30 10 1 4 *" Fire at 10:30 on 1st of March
87 | "15 15 15 10 10 *" Fire at Octorber 10th, at 15:15:15.
88 |
89 | ###Special characters
90 | Pomelo-schedule allow three kinds of spechial characters, they are '-', '/' and '.'.
91 |
92 | -: '-' means range. For example, 1-3 in the second field means the seconds 1, 2 and 3
93 |
94 | /: means increasement. For exapmle, 1/20 in the second field means 1, 21 and 41 second, and 1/2 means for every odd seconds as 1, 3, 5 ... ...
95 |
96 | ,: means additional values. For example, 1, 10, 15 in the second field means 1, 10 and 15 second. You can use '-', and '/' with ',', for example, 11,20-22,0/2 in the second filed means 11, 21 and all the even seconds.
97 |
98 | ##Cancel Job
99 | ``` javascript
100 | var schedule = require('../lib/schedule');
101 |
102 | var simpleJob = function(){
103 | console.log("run simple Job ");
104 | }
105 |
106 | //Add a simple job and save the id
107 | var id = schedule.scheduleJob({period: 1000}, simpleJob, {});
108 |
109 | /**
110 | * Do some thing else
111 | */
112 |
113 | //CancelJob
114 | schedule.cancelJob(id);
115 | ```
116 | When you cancel a job, it will stop schedule immidiatelly, and delete the job.
117 |
--------------------------------------------------------------------------------
/lib/cronTrigger.js:
--------------------------------------------------------------------------------
1 | /**
2 | * This is the trigger used to decode the cronTimer and calculate the next excution time of the cron Trigger.
3 | */
4 | var logger = require('log4js').getLogger(__filename);
5 |
6 | var SECOND = 0;
7 | var MIN = 1;
8 | var HOUR = 2;
9 | var DOM = 3;
10 | var MONTH = 4;
11 | var DOW = 5;
12 |
13 | var Limit = [
14 | [0, 59],
15 | [0, 59],
16 | [0, 24],
17 | [1, 31],
18 | [0, 11],
19 | [0, 6]
20 | ];
21 |
22 | /**
23 | * The constructor of the CronTrigger
24 | * @param trigger The trigger str used to build the cronTrigger instance
25 | */
26 | var CronTrigger = function(trigger, job) {
27 | this.trigger = this.decodeTrigger(trigger);
28 |
29 | this.nextTime = this.nextExcuteTime(Date.now());
30 |
31 | this.job = job;
32 | };
33 |
34 | var pro = CronTrigger.prototype;
35 |
36 | /**
37 | * Get the current excuteTime of trigger
38 | */
39 | pro.excuteTime = function() {
40 | return this.nextTime;
41 | };
42 |
43 | /**
44 | * Caculate the next valid cronTime after the given time
45 | * @param The given time point
46 | * @return The nearest valid time after the given time point
47 | */
48 | pro.nextExcuteTime = function(time) {
49 | //add 1s to the time so it must be the next time
50 | time = !!time ? time : this.nextTime;
51 | time += 1000;
52 |
53 | var cronTrigger = this.trigger;
54 | var date = new Date(time);
55 | date.setMilliseconds(0);
56 |
57 | outmost: while (true) {
58 | if (date.getFullYear() > 2999) {
59 | logger.error("Can't compute the next time, exceed the limit");
60 | return null;
61 | }
62 | if (!timeMatch(date.getMonth(), cronTrigger[MONTH])) {
63 | var nextMonth = nextCronTime(date.getMonth(), cronTrigger[MONTH]);
64 |
65 | if (nextMonth == null)
66 | return null;
67 |
68 | if (nextMonth <= date.getMonth()) {
69 | date.setYear(date.getFullYear() + 1);
70 | date.setMonth(0);
71 | date.setDate(1);
72 | date.setHours(0);
73 | date.setMinutes(0);
74 | date.setSeconds(0);
75 | continue;
76 | }
77 |
78 | date.setDate(1);
79 | date.setMonth(nextMonth);
80 | date.setHours(0);
81 | date.setMinutes(0);
82 | date.setSeconds(0);
83 | }
84 |
85 | if (!timeMatch(date.getDate(), cronTrigger[DOM]) || !timeMatch(date.getDay(), cronTrigger[DOW])) {
86 | var domLimit = getDomLimit(date.getFullYear(), date.getMonth());
87 |
88 | do {
89 | var nextDom = nextCronTime(date.getDate(), cronTrigger[DOM]);
90 | if (nextDom == null)
91 | return null;
92 |
93 | //If the date is in the next month, add month
94 | if (nextDom <= date.getDate() || nextDom > domLimit) {
95 | date.setDate(1);
96 | date.setMonth(date.getMonth() + 1);
97 | date.setHours(0);
98 | date.setMinutes(0);
99 | date.setSeconds(0);
100 | continue outmost;
101 | }
102 |
103 | date.setDate(nextDom);
104 | } while (!timeMatch(date.getDay(), cronTrigger[DOW]));
105 |
106 | date.setHours(0);
107 | date.setMinutes(0);
108 | date.setSeconds(0);
109 | }
110 |
111 | if (!timeMatch(date.getHours(), cronTrigger[HOUR])) {
112 | var nextHour = nextCronTime(date.getHours(), cronTrigger[HOUR]);
113 |
114 | if (nextHour <= date.getHours()) {
115 | date.setDate(date.getDate() + 1);
116 | date.setHours(nextHour);
117 | date.setMinutes(0);
118 | date.setSeconds(0);
119 | continue;
120 | }
121 |
122 | date.setHours(nextHour);
123 | date.setMinutes(0);
124 | date.setSeconds(0);
125 | }
126 |
127 | if (!timeMatch(date.getMinutes(), cronTrigger[MIN])) {
128 | var nextMinute = nextCronTime(date.getMinutes(), cronTrigger[MIN]);
129 |
130 | if (nextMinute <= date.getMinutes()) {
131 | date.setHours(date.getHours() + 1);
132 | date.setMinutes(nextMinute);
133 | date.setSeconds(0);
134 | continue;
135 | }
136 |
137 | date.setMinutes(nextMinute);
138 | date.setSeconds(0);
139 | }
140 |
141 | if (!timeMatch(date.getSeconds(), cronTrigger[SECOND])) {
142 | var nextSecond = nextCronTime(date.getSeconds(), cronTrigger[SECOND]);
143 |
144 | if (nextSecond <= date.getSeconds()) {
145 | date.setMinutes(date.getMinutes() + 1);
146 | date.setSeconds(nextSecond);
147 | continue;
148 | }
149 |
150 | date.setSeconds(nextSecond);
151 | }
152 | break;
153 | }
154 |
155 | this.nextTime = date.getTime();
156 | return this.nextTime;
157 | };
158 |
159 | /**
160 | * return the next match time of the given value
161 | * @param value The time value
162 | * @param cronTime The cronTime need to match
163 | * @return The match value or null if unmatch(it offten means an error occur).
164 | */
165 | function nextCronTime(value, cronTime) {
166 | value += 1;
167 |
168 | if (typeof(cronTime) == 'number') {
169 | if (cronTime == -1)
170 | return value;
171 | else
172 | return cronTime;
173 | } else if (typeof(cronTime) == 'object' && cronTime instanceof Array) {
174 | if (value <= cronTime[0] || value > cronTime[cronTime.length - 1])
175 | return cronTime[0];
176 |
177 | for (var i = 0; i < cronTime.length; i++)
178 | if (value <= cronTime[i])
179 | return cronTime[i];
180 | }
181 |
182 | logger.warn('Compute next Time error! value :' + value + ' cronTime : ' + cronTime);
183 | return null;
184 | }
185 |
186 | /**
187 | * Match the given value to the cronTime
188 | * @param value The given value
189 | * @param cronTime The cronTime
190 | * @return The match result
191 | */
192 | function timeMatch(value, cronTime) {
193 | if (typeof(cronTime) == 'number') {
194 | if (cronTime == -1)
195 | return true;
196 | if (value == cronTime)
197 | return true;
198 | return false;
199 | } else if (typeof(cronTime) == 'object' && cronTime instanceof Array) {
200 | if (value < cronTime[0] || value > cronTime[cronTime.length - 1])
201 | return false;
202 |
203 | for (var i = 0; i < cronTime.length; i++)
204 | if (value == cronTime[i])
205 | return true;
206 |
207 | return false;
208 | }
209 |
210 | return null;
211 | }
212 |
213 | /**
214 | * Decude the cronTrigger string to arrays
215 | * @param cronTimeStr The cronTimeStr need to decode, like "0 12 * * * 3"
216 | * @return The array to represent the cronTimer
217 | */
218 | pro.decodeTrigger = function(cronTimeStr) {
219 | cronTimeStr = cronTimeStr.trim();
220 | var cronTimes = cronTimeStr.split(/\s+/);
221 |
222 | if (cronTimes.length != 6) {
223 | console.log('error');
224 | return null;
225 | }
226 |
227 | for (var i = 0; i < cronTimes.length; i++) {
228 | cronTimes[i] = (this.decodeTimeStr(cronTimes[i], i));
229 |
230 | if (!checkNum(cronTimes[i], Limit[i][0], Limit[i][1])) {
231 | logger.error('Decode crontime error, value exceed limit!' +
232 | JSON.stringify({
233 | cronTime: cronTimes[i],
234 | limit: Limit[i]
235 | }));
236 | return null;
237 | }
238 | }
239 |
240 | return cronTimes;
241 | }
242 |
243 | /**
244 | * Decode the cron Time string
245 | * @param timeStr The cron time string, like: 1,2 or 1-3
246 | * @return A sorted array, like [1,2,3]
247 | */
248 | pro.decodeTimeStr = function(timeStr, type) {
249 | var result = {};
250 | var arr = [];
251 |
252 | if (timeStr == '*') {
253 | return -1;
254 | } else if (timeStr.search(',') > 0) {
255 | var timeArr = timeStr.split(',');
256 | for (var i = 0; i < timeArr.length; i++) {
257 | var time = timeArr[i];
258 | if (time.match(/^\d+-\d+$/)) {
259 | decodeRangeTime(result, time);
260 | } else if (time.match(/^\d+\/\d+/)) {
261 | decodePeriodTime(result, time, type);
262 | } else if (!isNaN(time)) {
263 | var num = Number(time);
264 | result[num] = num;
265 | } else
266 | return null;
267 | }
268 | } else if (timeStr.match(/^\d+-\d+$/)) {
269 | decodeRangeTime(result, timeStr);
270 | } else if (timeStr.match(/^\d+\/\d+/)) {
271 | decodePeriodTime(result, timeStr, type);
272 | } else if (!isNaN(timeStr)) {
273 | var num = Number(timeStr);
274 | result[num] = num;
275 | } else {
276 | return null;
277 | }
278 |
279 | for (var key in result) {
280 | arr.push(result[key]);
281 | }
282 |
283 | arr.sort(function(a, b) {
284 | return a - b;
285 | });
286 |
287 | return arr;
288 | }
289 |
290 | /**
291 | * Decode time range
292 | * @param map The decode map
293 | * @param timeStr The range string, like 2-5
294 | */
295 | function decodeRangeTime(map, timeStr) {
296 | var times = timeStr.split('-');
297 |
298 | times[0] = Number(times[0]);
299 | times[1] = Number(times[1]);
300 | if (times[0] > times[1]) {
301 | console.log("Error time range");
302 | return null;
303 | }
304 |
305 | for (var i = times[0]; i <= times[1]; i++) {
306 | map[i] = i;
307 | }
308 | }
309 |
310 | /**
311 | * Compute the period timer
312 | */
313 | function decodePeriodTime(map, timeStr, type) {
314 | var times = timeStr.split('/');
315 | var min = Limit[type][0];
316 | var max = Limit[type][1];
317 |
318 | var remind = Number(times[0]);
319 | var period = Number(times[1]);
320 |
321 | if (period == 0)
322 | return;
323 |
324 | for (var i = remind; i <= max; i += period) {
325 | // if (i % period == remind)
326 | map[i] = i;
327 | // }
328 | }
329 | }
330 |
331 | /**
332 | * Check if the numbers are valid
333 | * @param nums The numbers array need to check
334 | * @param min Minimus value
335 | * @param max Maximam value
336 | * @return If all the numbers are in the data range
337 | */
338 | function checkNum(nums, min, max) {
339 | if (nums == null)
340 | return false;
341 |
342 | if (nums == -1)
343 | return true;
344 |
345 | for (var i = 0; i < nums.length; i++) {
346 | if (nums[i] < min || nums[i] > max)
347 | return false;
348 | }
349 |
350 | return true;
351 | }
352 |
353 | /**
354 | * Get the date limit of given month
355 | * @param The given year
356 | * @month The given month
357 | * @return The date count of given month
358 | */
359 | function getDomLimit(year, month) {
360 | var date = new Date(year, month + 1, 0);
361 |
362 | return date.getDate();
363 | }
364 |
365 | /**
366 | * Create cronTrigger
367 | * @param trigger The Cron Trigger string
368 | * @return The Cron trigger
369 | */
370 | function createTrigger(trigger, job) {
371 | return new CronTrigger(trigger, job);
372 | }
373 |
374 | module.exports.createTrigger = createTrigger;
--------------------------------------------------------------------------------
/lib/cronTriggerDecoder.js:
--------------------------------------------------------------------------------
1 | var decoder = module.exports;
2 | decoder.decodeCronTime = decodeCronTime;
3 |
4 | var timer = {
5 | second: -1,
6 | min: -1,
7 | hour: -1,
8 | dom: -1,
9 | month: -1,
10 | dow: -1,
11 | executeTime: -1
12 | }
13 |
14 | var limit = [[0,59],[0,59],[0,24],[1,31],[1,12],[0,6]];
15 |
16 | function nexExcuteTime(time, timer){
17 | //add 1s to the time so it must be the next time
18 | time += 1000;
19 | var date = new Date(time);
20 | var nextTime = new Date(time);
21 |
22 | outmost:
23 | while(true){
24 | if(!timeMatch(date.getMonth(), timer.month)){
25 | var nextMonth = nextTime(date.getMonth(), timer.month);
26 | if(nextMonth < date.getMonth()){
27 | date.setYear(date.getYear()+1);
28 | }
29 | date.setMonth(nextMonth);
30 |
31 | date.setDate(1);
32 | date.setHours(0);
33 | date.setMinutes(0);
34 | date.setSeconds(0);
35 | }
36 |
37 | if(!timeMatch(date.getDate(), timer.dom)){
38 | do{
39 | var nextDom = nextTime(date.getDate(), timer.dom);
40 |
41 | //If the date is in the next month, add month
42 | if(nextDom <= date.getDate()){
43 | date.setMonth(date.getMonth() + 1);
44 | continue outmost;
45 | }
46 |
47 | //If the date exceed the limit, add month
48 | var domLimit = getDomLimit();
49 | if(nexDom > domLimit){
50 | date.setMonth(date.getMonth() + 1);
51 | continue outmost;
52 | }
53 |
54 | date.setDate(nextDom);
55 | }while(!timeMatch(date.getDay(), timer.dow));
56 |
57 | date.setHours(0);
58 | date.setMinutes(0);
59 | date.setSeconds(0);
60 | }
61 |
62 | if(!timeMatch(date.getHours(), timer.hour)){
63 | var nextHour = nextTime(date.getHours(), timer.hour);
64 |
65 | if(nextHour <= date.getHours()){
66 | date.setDate(date.getDate() + 1);
67 | continue;
68 | }
69 |
70 | date.setHours(nextHour);
71 | date.setMinutes(0);
72 | date.setSeconds(0);
73 | }
74 |
75 | if(!timeMatch(date.getMinutes(), timer.minute)){
76 | var nextMinute = nextTime(date.getMinutes(), timer.minute);
77 |
78 | if(nextMinute <= date.getMinutes()){
79 | date.setHours(date.getHours() + 1);
80 | continue;
81 | }
82 |
83 | date.setMinutes(nextMinute);
84 | date.setSeconds(0);
85 | }
86 |
87 | if(!timeMatch(date.getSeconds(), timer.seconde)){
88 | var nextSecond = nextTime(date.getSeconds(), timer.seconde);
89 |
90 | if(nextSecond <= date.getSeconds()){
91 | date.setMinutes()(date.getMinutes() + 1);
92 | continue;
93 | }
94 |
95 | date.setSeconds(nextSecond);
96 | }
97 |
98 | break;
99 | }
100 |
101 | return date.getTime();
102 | }
103 |
104 | /**
105 | * return the next match time of the given value
106 | */
107 | function nextTime(value, cronTime){
108 | if(typeof(cronTime) == 'number'){
109 | if(cronTime == -1)
110 | return value + 1;
111 | else
112 | return cronTime;
113 | }else if(typeof(cronTime) == 'array'){
114 | if(value < arr[0] || value > arr[arr.length -1])
115 | return arr[0];
116 |
117 | for(var i = 0; i < arr.length; i++)
118 | if(value < arr[i])
119 | return arr[i];
120 | }
121 |
122 | return null;
123 | }
124 |
125 | function timeMatch(value, cronTime){
126 | if(tyeof(cronTime) == 'number'){
127 | if(cronTime == -1)
128 | return true;
129 | if(value == cronTime)
130 | return true;
131 | return false;
132 | }else if(typeof(cronTime) == 'array'){
133 | if(value < arr[0] || value > arr[arr.length -1])
134 | return false;
135 |
136 | for(var i = 0; i < arr.length; i++)
137 | if(value == arr[i])
138 | return true;
139 |
140 | return false;
141 | }
142 |
143 | return null;
144 | }
145 |
146 | function getDomLimit(year, month){
147 | var date = new Date(year, month, 0);
148 |
149 | return date.getDate();
150 | }
151 |
152 | function decodeCronTime(cronTime){
153 | var timers = cronTime.split(/\s+/);
154 |
155 | if(timers.length != 6){
156 | return null;
157 | }
158 |
159 | for(var i = 0; i < timers.length; i++){
160 | timers[i] = (decodeTimeStr(timers[i]));
161 |
162 | if(!checkNum(timers[i], limit[i][0], limit[i][1])){
163 | return null;
164 | }
165 | }
166 |
167 | return timers;
168 | }
169 |
170 | function decodeTimeStr(timeStr){
171 | var result = {};
172 | var arr = [];
173 |
174 | if(timeStr=='*'){
175 | return -1;
176 | }else if(timeStr.search(',')>0){
177 | var timeStrArray = timeStr.split(',');
178 | for(var i = 0; i < timeStrArray.length; i++){
179 | var time = timeStrArray[i];
180 | if(time.match(/^\d+-\d+$/)){
181 | decodeRangeTime(result, time);
182 | }else if(!isNaN(timeStrArray[i]))
183 | result[i] = time;
184 | else
185 | return null;
186 | }
187 | }else if(timeStr.match(/^\d+-\d+$/)){
188 | decodeRangeTime(result, time);
189 | }else if(!isNaN(timeStr)){
190 | result[timeStr] = timeStr;
191 | }else{
192 | return null;
193 | }
194 |
195 | for(var key in result)
196 | arr.push(result[key]);
197 |
198 | arr.sort();
199 |
200 | return arr;
201 | }
202 |
203 | function decodeRangeTime(map, timeStr){
204 | var times = timeStr.split('-');
205 |
206 | if(times[0] > times[1])
207 | return null;
208 | for(var i = times[0]; i <= times[1]; i++)
209 | map[i] = i;
210 | }
211 |
212 | function checkNum(nums, min, max){
213 | if(nums == null)
214 | return false;
215 |
216 | if(nums == -1)
217 | return true;
218 |
219 | for(var i = 0; i < nums.length; i++){
220 | if(nums[i]max)
221 | return false;
222 | }
223 |
224 | return true;
225 | }
--------------------------------------------------------------------------------
/lib/job.js:
--------------------------------------------------------------------------------
1 | /**
2 | * This is the class of the job used in schedule module
3 | */
4 | var cronTrigger = require('./cronTrigger');
5 | var simpleTrigger = require('./simpleTrigger');
6 |
7 | var jobId = 1;
8 |
9 | var SIMPLE_JOB = 1;
10 | var CRON_JOB = 2;
11 | var jobCount = 0;
12 |
13 | var warnLimit = 500;
14 |
15 | var logger = require('log4js').getLogger(__filename);
16 |
17 |
18 | //For test
19 | var lateCount = 0;
20 |
21 | var Job = function(trigger, jobFunc, jobData){
22 | this.data = (!!jobData)?jobData:null;
23 | this.func = jobFunc;
24 |
25 | if(typeof(trigger) == 'string'){
26 | this.type = CRON_JOB;
27 | this.trigger = cronTrigger.createTrigger(trigger, this);
28 | }else if(typeof(trigger) == 'object'){
29 | this.type = SIMPLE_JOB;
30 | this.trigger = simpleTrigger.createTrigger(trigger, this);
31 | }
32 |
33 | this.id = jobId++;
34 | this.runTime = 0;
35 | };
36 |
37 | var pro = Job.prototype;
38 |
39 | /**
40 | * Run the job code
41 | */
42 | pro.run = function(){
43 | try{
44 | jobCount++;
45 | this.runTime++;
46 | var late = Date.now() - this.excuteTime();
47 | if(late>warnLimit)
48 | logger.warn('run Job count ' + jobCount + ' late :' + late + ' lateCount ' + (++lateCount));
49 | this.func(this.data);
50 | }catch(e){
51 | logger.error("Job run error for exception ! " + e.stack);
52 | }
53 | };
54 |
55 | /**
56 | * Compute the next excution time
57 | */
58 | pro.nextTime = function(){
59 | return this.trigger.nextExcuteTime();
60 | };
61 |
62 | pro.excuteTime = function(){
63 | return this.trigger.excuteTime();
64 | };
65 |
66 | /**
67 | * The Interface to create Job
68 | * @param trigger The trigger to use
69 | * @param jobFunc The function the job to run
70 | * @param jobDate The date the job use
71 | * @return The new instance of the give job or null if fail
72 | */
73 | function createJob(trigger, jobFunc, jobData){
74 | return new Job(trigger, jobFunc, jobData);
75 | }
76 |
77 | module.exports.createJob = createJob;
--------------------------------------------------------------------------------
/lib/priorityQueue.js:
--------------------------------------------------------------------------------
1 | /**
2 | * The PriorityQeueu class
3 | */
4 | var PriorityQueue = function(comparator){
5 | this.init(comparator);
6 | }
7 |
8 | var pro = PriorityQueue.prototype;
9 |
10 | pro.init = function(comparator){
11 | this._comparator = typeof(comparator)=='function'?comparator:this._defaultComparator;
12 |
13 | this._queue = [];
14 | this._tailPos = 0;
15 | }
16 |
17 | /**
18 | * Return the size of the pirority queue
19 | * @return PirorityQueue size
20 | */
21 | pro.size = function(){
22 | return this._tailPos;
23 | };
24 |
25 | /**
26 | * Insert an element to the queue
27 | * @param element The element to insert
28 | */
29 | pro.offer = function(element){
30 | var queue = this._queue;
31 | var compare = this._comparator;
32 |
33 | queue[this._tailPos++] = element;
34 |
35 | var pos = this._tailPos-1;
36 |
37 | while(pos > 0){
38 | var parentPos = (pos%2==0)?(pos/2-1):(pos-1)/2;
39 | if(compare(queue[parentPos], element)){
40 | queue[pos] = queue[parentPos];
41 | queue[parentPos] = element;
42 |
43 | pos = parentPos;
44 | }else{
45 | break;
46 | }
47 | }
48 | };
49 |
50 | /**
51 | * Get and remove the first element in the queue
52 | * @return The first element
53 | */
54 | pro.pop = function(){
55 | var queue = this._queue;
56 | var compare = this._comparator;
57 |
58 | if(this._tailPos == 0)
59 | return null;
60 |
61 |
62 | var headNode = queue[0];
63 |
64 | var tail = queue[this._tailPos - 1];
65 |
66 | var pos = 0;
67 | var left = pos*2 + 1;
68 | var right = left + 1;
69 | queue[pos] = tail;
70 | this._tailPos--;
71 |
72 | while(left < this._tailPos){
73 | if(right b;
106 | }
107 |
108 | module.exports.createPriorityQueue = function(comparator){
109 | return new PriorityQueue(comparator);
110 | }
--------------------------------------------------------------------------------
/lib/schedule.js:
--------------------------------------------------------------------------------
1 | /**
2 | * The main class and interface of the schedule module
3 | */
4 | var PriorityQueue = require('./priorityQueue');
5 | var Job = require('./job.js');
6 | var timerCount = 0;
7 |
8 | var logger = require('log4js').getLogger(__filename);
9 |
10 | var map = {};
11 | var queue = PriorityQueue.createPriorityQueue(comparator);
12 |
13 | var jobId = 0;
14 | var timer;
15 |
16 | //The accuracy of the scheduler, it will affect the performance when the schedule tasks are
17 | //crowded together
18 | var accuracy = 10;
19 |
20 | /**
21 | * Schedule a new Job
22 | */
23 | function scheduleJob(trigger, jobFunc, jobData){
24 | var job = Job.createJob(trigger, jobFunc, jobData);
25 | var excuteTime = job.excuteTime();
26 | var id = job.id;
27 |
28 | map[id] = job;
29 | var element = {
30 | id : id,
31 | time : excuteTime
32 | };
33 |
34 | var curJob = queue.peek();
35 | if(!curJob || excuteTime < curJob.time){
36 | queue.offer(element);
37 | setTimer(job);
38 |
39 | return job.id;
40 | }
41 |
42 | queue.offer(element);
43 | return job.id;
44 | }
45 |
46 | /**
47 | * Cancel Job
48 | */
49 | function cancelJob(id){
50 | var curJob = queue.peek();
51 | if(curJob && id === curJob.id){ // to avoid queue.peek() is null
52 | queue.pop();
53 | delete map[id];
54 |
55 | clearTimeout(timer);
56 | excuteJob();
57 | }
58 | delete map[id];
59 | return true;
60 | }
61 |
62 | /**
63 | * Clear last timeout and schedule the next job, it will automaticly run the job that
64 | * need to run now
65 | * @param job The job need to schedule
66 | * @return void
67 | */
68 | function setTimer(job){
69 | clearTimeout(timer);
70 |
71 | timer = setTimeout(excuteJob, job.excuteTime()-Date.now());
72 | }
73 |
74 | /**
75 | * The function used to ran the schedule job, and setTimeout for next running job
76 | */
77 | function excuteJob(){
78 | var job = peekNextJob();
79 | var nextJob;
80 |
81 | while(!!job && (job.excuteTime()-Date.now()) 0);
117 |
118 | return (!!job)?job:null;
119 | }
120 |
121 | /**
122 | * Return and remove the next valid job
123 | * @return Next valid job
124 | */
125 | function getNextJob(){
126 | var job = null;
127 |
128 | while(!job && queue.size() > 0){
129 | var id = queue.pop().id;
130 | job = map[id];
131 | }
132 |
133 | return (!!job)?job:null;
134 | }
135 |
136 | function comparator(e1, e2){
137 | return e1.time > e2.time;
138 | }
139 |
140 | module.exports.scheduleJob = scheduleJob;
141 | module.exports.cancelJob = cancelJob;
142 |
--------------------------------------------------------------------------------
/lib/simpleTrigger.js:
--------------------------------------------------------------------------------
1 | /**
2 | * This is the tirgger that use an object as trigger.
3 | */
4 | var SKIP_OLD_JOB = false;
5 |
6 | /**
7 | * The constructor of simple trigger
8 | */
9 | var SimpleTrigger = function(trigger, job){
10 | this.nextTime = (!!trigger.start)?trigger.start:Date.now();
11 |
12 | //The rec
13 | this.period = (!!trigger.period)?trigger.period:-1;
14 |
15 | //The running count of the job, -1 means no limit
16 | this.count = (!!trigger.count)?trigger.count:-1;
17 |
18 | this.job = job;
19 | };
20 |
21 | var pro = SimpleTrigger.prototype;
22 |
23 | /**
24 | * Get the current excuteTime of rigger
25 | */
26 | pro.excuteTime = function(){
27 | return this.nextTime;
28 | };
29 |
30 | /**
31 | * Get the next excuteTime of the trigger, and set the trigger's excuteTime
32 | * @return Next excute time
33 | */
34 | pro.nextExcuteTime = function(){
35 | var period = this.period;
36 |
37 | if((this.count > 0 && this.count <= this.job.runTime) || period <= 0)
38 | return null;
39 |
40 | this.nextTime += period;
41 |
42 | if(SKIP_OLD_JOB && this.nextTime < Date.now()){
43 | this.nextTime += Math.floor((Date.now()-this.nextTime)/period) * period;
44 | }
45 |
46 | return this.nextTime;
47 | };
48 |
49 | /**
50 | * Create Simple trigger
51 | */
52 | function createTrigger(trigger, job){
53 | return new SimpleTrigger(trigger, job);
54 | }
55 |
56 | module.exports.createTrigger = createTrigger;
--------------------------------------------------------------------------------
/node_modules/log4js/.npmignore:
--------------------------------------------------------------------------------
1 | *.log
2 | *.log??
3 |
--------------------------------------------------------------------------------
/node_modules/log4js/.project:
--------------------------------------------------------------------------------
1 |
2 |
3 | log4js
4 |
6 |
7 |
8 |
9 |
10 |
11 |
12 |
--------------------------------------------------------------------------------
/node_modules/log4js/.travis.yml:
--------------------------------------------------------------------------------
1 | language: node_js
2 | node_js:
3 | - 0.4
4 | - 0.5
5 | - 0.6
6 |
--------------------------------------------------------------------------------
/node_modules/log4js/example-connect-logger.js:
--------------------------------------------------------------------------------
1 | var log4js = require('./lib/log4js');
2 | log4js.addAppender(log4js.fileAppender('cheese.log'), 'cheese');
3 |
4 | var logger = log4js.getLogger('cheese');
5 | logger.setLevel('INFO');
6 |
7 | var app = require('express').createServer();
8 | app.configure(function() {
9 | app.use(log4js.connectLogger(logger, { level: log4js.levels.INFO }));
10 | });
11 | app.get('*', function(req,res) {
12 | res.send('hello world\n cheese \n');
13 | });
14 | app.listen(5000);
15 |
--------------------------------------------------------------------------------
/node_modules/log4js/example-socket.js:
--------------------------------------------------------------------------------
1 | var log4js = require('./lib/log4js')
2 | , cluster = require('cluster')
3 | , numCPUs = require('os').cpus().length
4 | , i = 0;
5 |
6 | if (cluster.isMaster) {
7 | log4js.configure({
8 | appenders: [
9 | {
10 | type: "multiprocess",
11 | mode: "master",
12 | appender: {
13 | type: "console"
14 | }
15 | }
16 | ]
17 | });
18 |
19 | console.info("Master creating %d workers", numCPUs);
20 | for (i=0; i < numCPUs; i++) {
21 | cluster.fork();
22 | }
23 |
24 | cluster.on('death', function(worker) {
25 | console.info("Worker %d died.", worker.pid);
26 | // cluster.fork();
27 | });
28 | } else {
29 | log4js.configure({
30 | appenders: [
31 | {
32 | type: "multiprocess",
33 | mode: "worker"
34 | }
35 | ]
36 | });
37 | function logSomething(i) {
38 | return function() {
39 | console.info("Worker %d - logging something %d", process.pid, i);
40 | }
41 | }
42 |
43 | console.info("Worker %d started.", process.pid);
44 | for (i=0; i < 1000; i++) {
45 | process.nextTick(logSomething(i));
46 | }
47 | }
48 |
49 |
50 |
51 |
--------------------------------------------------------------------------------
/node_modules/log4js/example.js:
--------------------------------------------------------------------------------
1 | var log4js = require('./lib/log4js');
2 | //log the cheese logger messages to a file, and the console ones as well.
3 | log4js.addAppender(log4js.fileAppender('cheese.log'), 'cheese', 'console');
4 |
5 | var logger = log4js.getLogger('cheese');
6 | //only errors and above get logged.
7 | logger.setLevel('ERROR');
8 |
9 | //console logging methds have been replaced with log4js ones.
10 | console.error("AAArgh! Something went wrong", { some: "otherObject", useful_for: "debug purposes" });
11 |
12 | //these will not appear (logging level beneath error)
13 | logger.trace('Entering cheese testing');
14 | logger.debug('Got cheese.');
15 | logger.info('Cheese is Gouda.');
16 | logger.warn('Cheese is quite smelly.');
17 | //these end up on the console and in cheese.log
18 | logger.error('Cheese %s is too ripe!', "gouda");
19 | logger.fatal('Cheese was breeding ground for listeria.');
20 |
21 |
22 |
23 |
--------------------------------------------------------------------------------
/node_modules/log4js/lib/appenders/console.js:
--------------------------------------------------------------------------------
1 | var layouts = require('../layouts'),
2 | consoleLog = console.log;
3 |
4 | function consoleAppender (layout) {
5 | layout = layout || layouts.colouredLayout;
6 | return function(loggingEvent) {
7 | consoleLog(layout(loggingEvent));
8 | };
9 | }
10 |
11 | function configure(config) {
12 | var layout;
13 | if (config.layout) {
14 | layout = layouts.layout(config.layout.type, config.layout);
15 | }
16 | return consoleAppender(layout);
17 | }
18 |
19 | exports.name = "console";
20 | exports.appender = consoleAppender;
21 | exports.configure = configure;
22 |
--------------------------------------------------------------------------------
/node_modules/log4js/lib/appenders/file.js:
--------------------------------------------------------------------------------
1 | var layouts = require('../layouts')
2 | , path = require('path')
3 | , fs = require('fs')
4 | , streams = require('../streams');
5 |
6 | /**
7 | * File Appender writing the logs to a text file. Supports rolling of logs by size.
8 | *
9 | * @param file file log messages will be written to
10 | * @param layout a function that takes a logevent and returns a string (defaults to basicLayout).
11 | * @param logSize - the maximum size (in bytes) for a log file, if not provided then logs won't be rotated.
12 | * @param numBackups - the number of log files to keep after logSize has been reached (default 5)
13 | */
14 | function fileAppender (file, layout, logSize, numBackups) {
15 | var bytesWritten = 0;
16 | file = path.normalize(file);
17 | layout = layout || layouts.basicLayout;
18 | numBackups = numBackups === undefined ? 5 : numBackups;
19 | //there has to be at least one backup if logSize has been specified
20 | numBackups = numBackups === 0 ? 1 : numBackups;
21 |
22 | function openTheStream(file, fileSize, numFiles) {
23 | var stream;
24 | if (fileSize) {
25 | stream = new streams.BufferedWriteStream(
26 | new streams.RollingFileStream(
27 | file,
28 | fileSize,
29 | numFiles
30 | )
31 | );
32 | } else {
33 | stream = new streams.BufferedWriteStream(fs.createWriteStream(file, { encoding: "utf8", mode: 0644, flags: 'a' }));
34 | }
35 | stream.on("error", function (err) {
36 | console.error("log4js.fileAppender - Writing to file %s, error happened ", file, err);
37 | });
38 | return stream;
39 | }
40 |
41 | var logFile = openTheStream(file, logSize, numBackups);
42 |
43 | //close the file on process exit.
44 | process.on('exit', function() {
45 | logFile.end();
46 | });
47 |
48 | return function(loggingEvent) {
49 | logFile.write(layout(loggingEvent)+'\n', "utf8");
50 | };
51 | }
52 |
53 | function configure(config) {
54 | var layout;
55 | if (config.layout) {
56 | layout = layouts.layout(config.layout.type, config.layout);
57 | }
58 | return fileAppender(config.filename, layout, config.maxLogSize, config.backups);
59 | }
60 |
61 | exports.name = "file";
62 | exports.appender = fileAppender;
63 | exports.configure = configure;
64 |
--------------------------------------------------------------------------------
/node_modules/log4js/lib/appenders/gelf.js:
--------------------------------------------------------------------------------
1 | var compress = require('compress-buffer').compress;
2 | var layouts = require('../layouts');
3 | var levels = require('../levels');
4 | var dgram = require('dgram');
5 | var util = require('util');
6 |
7 | var LOG_EMERG=0; // system is unusable
8 | var LOG_ALERT=1; // action must be taken immediately
9 | var LOG_CRIT=2; // critical conditions
10 | var LOG_ERR=3; // error conditions
11 | var LOG_ERROR=3; // because people WILL typo
12 | var LOG_WARNING=4; // warning conditions
13 | var LOG_NOTICE=5; // normal, but significant, condition
14 | var LOG_INFO=6; // informational message
15 | var LOG_DEBUG=7; // debug-level message
16 |
17 | var levelMapping = {};
18 | levelMapping[levels.ALL] = LOG_DEBUG;
19 | levelMapping[levels.TRACE] = LOG_DEBUG;
20 | levelMapping[levels.DEBUG] = LOG_DEBUG;
21 | levelMapping[levels.INFO] = LOG_INFO;
22 | levelMapping[levels.WARN] = LOG_WARNING;
23 | levelMapping[levels.ERROR] = LOG_ERR;
24 | levelMapping[levels.FATAL] = LOG_CRIT;
25 |
26 | /**
27 | * GELF appender that supports sending UDP packets to a GELF compatible server such as Graylog
28 | *
29 | * @param layout a function that takes a logevent and returns a string (defaults to none).
30 | * @param host - host to which to send logs (default:localhost)
31 | * @param port - port at which to send logs to (default:12201)
32 | * @param hostname - hostname of the current host (default:os hostname)
33 | * @param facility - facility to log to (default:nodejs-server)
34 | */
35 | function gelfAppender (layout, host, port, hostname, facility) {
36 |
37 | host = host || 'localhost';
38 | port = port || 12201;
39 | hostname = hostname || require('os').hostname();
40 | facility = facility || 'nodejs-server';
41 | layout = layout || layouts.messagePassThroughLayout;
42 |
43 | var client = dgram.createSocket("udp4");
44 |
45 | process.on('exit', function() {
46 | if (client) client.close();
47 | });
48 |
49 | function preparePacket(loggingEvent) {
50 | var msg = {};
51 | msg.full_message = layout(loggingEvent);
52 | msg.short_message = msg.full_message;
53 |
54 | msg.version="1.0";
55 | msg.timestamp = msg.timestamp || new Date().getTime() / 1000 >> 0;
56 | msg.host = hostname;
57 | msg.level = levelMapping[loggingEvent.level || levels.DEBUG];
58 | msg.facility = facility;
59 | return msg;
60 | }
61 |
62 | function sendPacket(packet) {
63 | try {
64 | client.send(packet, 0, packet.length, port, host);
65 | } catch(e) {}
66 | }
67 |
68 | return function(loggingEvent) {
69 | var message = preparePacket(loggingEvent);
70 | var packet = compress(new Buffer(JSON.stringify(message)));
71 | if (packet.length > 8192) {
72 | util.debug("Message packet length (" + packet.length + ") is larger than 8k. Not sending");
73 | } else {
74 | sendPacket(packet);
75 | }
76 | };
77 | }
78 |
79 | function configure(config) {
80 | var layout;
81 | if (config.layout) {
82 | layout = layouts.layout(config.layout.type, config.layout);
83 | }
84 | return gelfAppender(layout, config.host, config.port, config.hostname, config.facility);
85 | }
86 |
87 | exports.name = "gelf";
88 | exports.appender = gelfAppender;
89 | exports.configure = configure;
90 |
--------------------------------------------------------------------------------
/node_modules/log4js/lib/appenders/hookio.js:
--------------------------------------------------------------------------------
1 | var log4js = require('../log4js');
2 | var layouts = require('../layouts');
3 | var Hook = require('hook.io').Hook;
4 | var util = require('util');
5 |
6 | var Logger = function createLogger(options) {
7 | var self = this;
8 | var actualAppender = options.actualAppender;
9 | Hook.call(self, options);
10 | self.on('hook::ready', function hookReady() {
11 | self.on('*::' + options.name + '::log', function log(loggingEvent) {
12 | deserializeLoggingEvent(loggingEvent);
13 | actualAppender(loggingEvent);
14 | });
15 | });
16 | }
17 | util.inherits(Logger, Hook);
18 |
19 | function deserializeLoggingEvent(loggingEvent) {
20 | loggingEvent.startTime = new Date(loggingEvent.startTime);
21 | loggingEvent.level.toString = function levelToString() {
22 | return loggingEvent.level.levelStr;
23 | };
24 | }
25 |
26 | function initHook(hookioOptions) {
27 | var loggerHook;
28 | if (hookioOptions.mode === 'master') {
29 | // Start the master hook, handling the actual logging
30 | loggerHook = new Logger(hookioOptions);
31 | } else {
32 | // Start a worker, just emitting events for a master
33 | loggerHook = new Hook(hookioOptions);
34 | }
35 | loggerHook.start();
36 | return loggerHook;
37 | }
38 |
39 | function getBufferedHook(hook, eventName) {
40 | var hookBuffer = [];
41 | var hookReady = false;
42 | hook.on('hook::ready', function emptyBuffer() {
43 | hookBuffer.forEach(function logBufferItem(loggingEvent) {
44 | hook.emit(eventName, loggingEvent);
45 | })
46 | hookReady = true;
47 | });
48 |
49 | return function log(loggingEvent) {
50 | if (hookReady) {
51 | hook.emit(eventName, loggingEvent);
52 | } else {
53 | hookBuffer.push(loggingEvent);
54 | }
55 | }
56 | }
57 |
58 | function createAppender(hookioOptions) {
59 | var loggerHook = initHook(hookioOptions);
60 | var loggerEvent = hookioOptions.name + '::log';
61 | return getBufferedHook(loggerHook, loggerEvent);
62 | }
63 |
64 | function configure(config) {
65 | var actualAppender;
66 | if (config.appender && config.mode === 'master') {
67 | log4js.loadAppender(config.appender.type);
68 | actualAppender = log4js.appenderMakers[config.appender.type](config.appender);
69 | config.actualAppender = actualAppender;
70 | }
71 | return createAppender(config);
72 | }
73 |
74 | exports.name = 'hookio';
75 | exports.appender = createAppender;
76 | exports.configure = configure;
77 |
--------------------------------------------------------------------------------
/node_modules/log4js/lib/appenders/logLevelFilter.js:
--------------------------------------------------------------------------------
1 | var levels = require('../levels');
2 | var log4js = require('../log4js');
3 |
4 | function logLevelFilter (levelString, appender) {
5 | var level = levels.toLevel(levelString);
6 | return function(logEvent) {
7 | if (logEvent.level.isGreaterThanOrEqualTo(level)) {
8 | appender(logEvent);
9 | }
10 | }
11 | }
12 |
13 | function configure(config) {
14 | log4js.loadAppender(config.appender.type);
15 | var appender = log4js.appenderMakers[config.appender.type](config.appender);
16 | return logLevelFilter(config.level, appender);
17 | }
18 |
19 | exports.name = "logLevelFilter";
20 | exports.appender = logLevelFilter;
21 | exports.configure = configure;
22 |
--------------------------------------------------------------------------------
/node_modules/log4js/lib/appenders/multiprocess.js:
--------------------------------------------------------------------------------
1 | var log4js = require('../log4js');
2 | var layouts = require('../layouts');
3 | var net = require('net');
4 | var util = require('util');
5 |
6 | var LogServer = function createLogServer(config) {
7 | var actualAppender = config.actualAppender;
8 | var server = net.createServer(function serverCreated(clientSocket) {
9 | clientSocket.on('connect', function clientConnected() {
10 | var logMessage = '';
11 | clientSocket.on('data', function chunkReceived(chunk) {
12 | logMessage += chunk;
13 | });
14 | clientSocket.on('end', function gotChunks() {
15 | try {
16 | var loggingEvent = JSON.parse(logMessage);
17 | deserializeLoggingEvent(loggingEvent);
18 | actualAppender(loggingEvent);
19 | } catch (e) {
20 | // JSON.parse failed, just log the contents probably a naughty.
21 | actualAppender(createLoggingEvent('ERROR', 'Unable to parse log: ' + logMessage));
22 | }
23 | });
24 | });
25 | });
26 | server.listen(config.loggerPort || 5000, config.loggerHost || 'localhost');
27 | }
28 |
29 | function createLoggingEvent(level, message) {
30 | return {
31 | startTime: new Date(),
32 | categoryName: 'log4js',
33 | level: { toString: function () {
34 | return level;
35 | }},
36 | data: [ message ]
37 | };
38 | }
39 |
40 | function deserializeLoggingEvent(loggingEvent) {
41 | loggingEvent.startTime = new Date(loggingEvent.startTime);
42 | loggingEvent.level.toString = function levelToString() {
43 | return loggingEvent.level.levelStr;
44 | };
45 | }
46 |
47 | function workerAppender(config) {
48 | return function log(loggingEvent) {
49 | var socket = net.createConnection(config.loggerPort || 5000, config.loggerHost || 'localhost');
50 | socket.on('connect', function socketConnected() {
51 | socket.end(JSON.stringify(loggingEvent), 'utf8');
52 | });
53 | };
54 | }
55 |
56 | function createAppender(config) {
57 | if (config.mode === 'master') {
58 | var server = new LogServer(config);
59 | return config.actualAppender;
60 | } else {
61 | return workerAppender(config);
62 | }
63 | }
64 |
65 | function configure(config) {
66 | var actualAppender;
67 | if (config.appender && config.mode === 'master') {
68 | log4js.loadAppender(config.appender.type);
69 | actualAppender = log4js.appenderMakers[config.appender.type](config.appender);
70 | config.actualAppender = actualAppender;
71 | }
72 | return createAppender(config);
73 | }
74 |
75 | exports.name = 'multiprocess';
76 | exports.appender = createAppender;
77 | exports.configure = configure;
78 |
--------------------------------------------------------------------------------
/node_modules/log4js/lib/appenders/smtp.js:
--------------------------------------------------------------------------------
1 | var layouts = require("../layouts"),
2 | mailer = require("nodemailer");
3 |
4 | /**
5 | * SMTP Appender. Sends logging events using SMTP protocol.
6 | * It can either send an email on each event or group several logging events gathered during specified interval.
7 | *
8 | * @param recipients comma separated list of email recipients
9 | * @param sender sender of all emails (defaults to SMTP user)
10 | * @param subject subject of all email messages (defaults to first event's message)
11 | * @param layout a function that takes a logevent and returns a string (defaults to basicLayout).
12 | * @param smtpConfig SMTP configuration for 'nodemailer'
13 | * @param sendInterval the time in seconds between sending attempts (defaults to 0);
14 | * all events are buffered and sent in one email during this time; if 0 than every event sends an email
15 | */
16 | function smtpAppender(recipients, sender, subject, layout, smtpConfig, sendInterval) {
17 | sender = sender || smtpConfig.user;
18 | layout = layout || layouts.basicLayout;
19 | subjectLayout = layouts.messagePassThroughLayout;
20 | mailer.SMTP = smtpConfig;
21 | sendInterval = sendInterval*1000 || 0;
22 |
23 | var logEventBuffer = [];
24 | var sendTimer;
25 |
26 | function sendBuffer() {
27 | if (logEventBuffer.length == 0)
28 | return;
29 |
30 | var firstEvent = logEventBuffer[0];
31 | var body = "";
32 | while (logEventBuffer.length > 0) {
33 | body += layout(logEventBuffer.shift()) + "\n";
34 | }
35 |
36 | var msg = {
37 | sender: sender,
38 | to: recipients,
39 | subject: subject || subjectLayout(firstEvent),
40 | body: body
41 | };
42 | mailer.send_mail(msg, function(error, success) {
43 | if (error) {
44 | console.error("log4js.smtpAppender - Error happened ", error);
45 | }
46 | });
47 | }
48 |
49 | function scheduleSend() {
50 | if (!sendTimer)
51 | sendTimer = setTimeout(function() {
52 | sendTimer = null;
53 | sendBuffer();
54 | }, sendInterval);
55 | }
56 |
57 | return function(loggingEvent) {
58 | logEventBuffer.push(loggingEvent);
59 | if (sendInterval > 0)
60 | scheduleSend();
61 | else
62 | sendBuffer();
63 | };
64 | }
65 |
66 | function configure(config) {
67 | var layout;
68 | if (config.layout) {
69 | layout = layouts.layout(config.layout.type, config.layout);
70 | }
71 | return smtpAppender(config.recipients, config.sender, config.subject, layout, config.smtp, config.sendInterval);
72 | }
73 |
74 | exports.name = "smtp";
75 | exports.appender = smtpAppender;
76 | exports.configure = configure;
77 |
--------------------------------------------------------------------------------
/node_modules/log4js/lib/connect-logger.js:
--------------------------------------------------------------------------------
1 | var levels = require("./levels");
2 | /**
3 | * Log requests with the given `options` or a `format` string.
4 | *
5 | * Options:
6 | *
7 | * - `format` Format string, see below for tokens
8 | * - `level` A log4js levels instance.
9 | *
10 | * Tokens:
11 | *
12 | * - `:req[header]` ex: `:req[Accept]`
13 | * - `:res[header]` ex: `:res[Content-Length]`
14 | * - `:http-version`
15 | * - `:response-time`
16 | * - `:remote-addr`
17 | * - `:date`
18 | * - `:method`
19 | * - `:url`
20 | * - `:referrer`
21 | * - `:user-agent`
22 | * - `:status`
23 | *
24 | * @param {String|Function|Object} format or options
25 | * @return {Function}
26 | * @api public
27 | */
28 |
29 | function getLogger(logger4js, options) {
30 | if ('object' == typeof options) {
31 | options = options || {};
32 | } else if (options) {
33 | options = { format: options };
34 | } else {
35 | options = {};
36 | }
37 |
38 | var thislogger = logger4js
39 | , level = levels.toLevel(options.level, levels.INFO)
40 | , fmt = options.format || ':remote-addr - - ":method :url HTTP/:http-version" :status :content-length ":referrer" ":user-agent"'
41 | , nolog = options.nolog ? createNoLogCondition(options.nolog) : null;
42 |
43 | return function (req, res, next) {
44 |
45 | // mount safety
46 | if (req._logging) return next();
47 |
48 | // nologs
49 | if(nolog && nolog.test(req.originalUrl)) return next();
50 |
51 | if (thislogger.isLevelEnabled(level)) {
52 |
53 | var start = +new Date
54 | , statusCode
55 | , writeHead = res.writeHead
56 | , end = res.end
57 | , url = req.originalUrl;
58 |
59 | // flag as logging
60 | req._logging = true;
61 |
62 | // proxy for statusCode.
63 | res.writeHead = function(code, headers){
64 | res.writeHead = writeHead;
65 | res.writeHead(code, headers);
66 | res.__statusCode = statusCode = code;
67 | res.__headers = headers || {};
68 | };
69 |
70 | // proxy end to output a line to the provided logger.
71 | res.end = function(chunk, encoding) {
72 | res.end = end;
73 | res.end(chunk, encoding);
74 | res.responseTime = +new Date - start;
75 | if ('function' == typeof fmt) {
76 | var line = fmt(req, res, function(str){ return format(str, req, res); });
77 | if (line) thislogger.log(level, line);
78 | } else {
79 | thislogger.log(level, format(fmt, req, res));
80 | }
81 | };
82 | }
83 |
84 | //ensure next gets always called
85 | next();
86 | };
87 | }
88 |
89 | /**
90 | * Return formatted log line.
91 | *
92 | * @param {String} str
93 | * @param {IncomingMessage} req
94 | * @param {ServerResponse} res
95 | * @return {String}
96 | * @api private
97 | */
98 |
99 | function format(str, req, res) {
100 | return str
101 | .replace(':url', req.originalUrl)
102 | .replace(':method', req.method)
103 | .replace(':status', res.__statusCode || res.statusCode)
104 | .replace(':response-time', res.responseTime)
105 | .replace(':date', new Date().toUTCString())
106 | .replace(':referrer', req.headers['referer'] || req.headers['referrer'] || '')
107 | .replace(':http-version', req.httpVersionMajor + '.' + req.httpVersionMinor)
108 | .replace(':remote-addr', req.socket && (req.socket.remoteAddress || (req.socket.socket && req.socket.socket.remoteAddress)))
109 | .replace(':user-agent', req.headers['user-agent'] || '')
110 | .replace(':content-length', (res._headers && res._headers['content-length']) || (res.__headers && res.__headers['Content-Length']) || '-')
111 | .replace(/:req\[([^\]]+)\]/g, function(_, field){ return req.headers[field.toLowerCase()]; })
112 | .replace(/:res\[([^\]]+)\]/g, function(_, field){
113 | return res._headers
114 | ? (res._headers[field.toLowerCase()] || res.__headers[field])
115 | : (res.__headers && res.__headers[field]);
116 | });
117 | }
118 |
119 | /**
120 | * Return RegExp Object about nolog
121 | *
122 | * @param {String} nolog
123 | * @return {RegExp}
124 | * @api private
125 | */
126 |
127 | /**
128 | * syntax
129 | * 1. String
130 | * 1.1 "\\.gif"
131 | * NOT LOGGING http://example.com/hoge.gif and http://example.com/hoge.gif?fuga
132 | * LOGGING http://example.com/hoge.agif
133 | * 1.2 in "\\.gif|\\.jpg$"
134 | * NOT LOGGING http://example.com/hoge.gif and http://example.com/hoge.gif?fuga and http://example.com/hoge.jpg?fuga
135 | * LOGGING http://example.com/hoge.agif, http://example.com/hoge.ajpg and http://example.com/hoge.jpg?hoge
136 | * 1.3 in "\\.(gif|jpe?g|png)$"
137 | * NOT LOGGING http://example.com/hoge.gif and http://example.com/hoge.jpeg
138 | * LOGGING http://example.com/hoge.gif?uid=2 and http://example.com/hoge.jpg?pid=3
139 | * 2. RegExp
140 | * 2.1 in /\.(gif|jpe?g|png)$/
141 | * SAME AS 1.3
142 | * 3. Array
143 | * 3.1 ["\\.jpg$", "\\.png", "\\.gif"]
144 | * SAME AS "\\.jpg|\\.png|\\.gif"
145 | */
146 | function createNoLogCondition(nolog, type) {
147 | if(!nolog) return null;
148 | type = type || '';
149 |
150 | if(nolog instanceof RegExp){
151 | if(type === 'string')
152 | return nolog.source;
153 | return nolog;
154 | } else if(typeof nolog === 'string'){
155 | if(type === 'string')
156 | return nolog;
157 | try{
158 | return new RegExp(nolog);
159 | } catch (ex) {
160 | return null;
161 | }
162 | } else if(nolog instanceof Array){
163 | var regexps = nolog.map(function(o){ return createNoLogCondition(o, 'string')});
164 | return new RegExp(regexps.join('|'));
165 | }
166 | }
167 |
168 | exports.connectLogger = getLogger;
--------------------------------------------------------------------------------
/node_modules/log4js/lib/date_format.js:
--------------------------------------------------------------------------------
1 | exports.ISO8601_FORMAT = "yyyy-MM-dd hh:mm:ss.SSS";
2 | exports.ISO8601_WITH_TZ_OFFSET_FORMAT = "yyyy-MM-ddThh:mm:ssO";
3 | exports.DATETIME_FORMAT = "dd MM yyyy hh:mm:ss.SSS";
4 | exports.ABSOLUTETIME_FORMAT = "hh:mm:ss.SSS";
5 |
6 | exports.asString = function(/*format,*/ date) {
7 | var format = exports.ISO8601_FORMAT;
8 | if (typeof(date) === "string") {
9 | format = arguments[0];
10 | date = arguments[1];
11 | }
12 |
13 | var vDay = addZero(date.getDate());
14 | var vMonth = addZero(date.getMonth()+1);
15 | var vYearLong = addZero(date.getFullYear());
16 | var vYearShort = addZero(date.getFullYear().toString().substring(3,4));
17 | var vYear = (format.indexOf("yyyy") > -1 ? vYearLong : vYearShort);
18 | var vHour = addZero(date.getHours());
19 | var vMinute = addZero(date.getMinutes());
20 | var vSecond = addZero(date.getSeconds());
21 | var vMillisecond = padWithZeros(date.getMilliseconds(), 3);
22 | var vTimeZone = offset(date);
23 | var formatted = format
24 | .replace(/dd/g, vDay)
25 | .replace(/MM/g, vMonth)
26 | .replace(/y{1,4}/g, vYear)
27 | .replace(/hh/g, vHour)
28 | .replace(/mm/g, vMinute)
29 | .replace(/ss/g, vSecond)
30 | .replace(/SSS/g, vMillisecond)
31 | .replace(/O/g, vTimeZone);
32 | return formatted;
33 |
34 | function padWithZeros(vNumber, width) {
35 | var numAsString = vNumber + "";
36 | while (numAsString.length < width) {
37 | numAsString = "0" + numAsString;
38 | }
39 | return numAsString;
40 | }
41 |
42 | function addZero(vNumber) {
43 | return padWithZeros(vNumber, 2);
44 | }
45 |
46 | /**
47 | * Formats the TimeOffest
48 | * Thanks to http://www.svendtofte.com/code/date_format/
49 | * @private
50 | */
51 | function offset(date) {
52 | // Difference to Greenwich time (GMT) in hours
53 | var os = Math.abs(date.getTimezoneOffset());
54 | var h = String(Math.floor(os/60));
55 | var m = String(os%60);
56 | h.length == 1? h = "0"+h:1;
57 | m.length == 1? m = "0"+m:1;
58 | return date.getTimezoneOffset() < 0 ? "+"+h+m : "-"+h+m;
59 | }
60 | };
61 |
--------------------------------------------------------------------------------
/node_modules/log4js/lib/layouts.js:
--------------------------------------------------------------------------------
1 | var dateFormat = require('./date_format')
2 | , util = require('util')
3 | , replacementRegExp = /%[sdj]/g
4 | , layoutMakers = {
5 | "messagePassThrough": function() { return messagePassThroughLayout; }
6 | , "basic": function() { return basicLayout; }
7 | , "colored": function() { return colouredLayout; }
8 | , "coloured": function() { return colouredLayout; }
9 | , "pattern": function (config) {
10 | var pattern = config.pattern || undefined;
11 | return patternLayout(pattern);
12 | }
13 | }
14 | , colours = {
15 | ALL: "grey"
16 | , TRACE: "blue"
17 | , DEBUG: "cyan"
18 | , INFO: "green"
19 | , WARN: "yellow"
20 | , ERROR: "red"
21 | , FATAL: "magenta"
22 | , OFF: "grey"
23 | };
24 |
25 |
26 | function formatLogData(logData) {
27 | var output = ""
28 | , data = Array.isArray(logData) ? logData.slice() : Array.prototype.slice.call(arguments)
29 | , format = data.shift();
30 |
31 | if (typeof format === "string") {
32 | output = format.replace(replacementRegExp, function(match) {
33 | switch (match) {
34 | case "%s": return new String(data.shift());
35 | case "%d": return new Number(data.shift());
36 | case "%j": return JSON.stringify(data.shift());
37 | default:
38 | return match;
39 | };
40 | });
41 | } else {
42 | //put it back, it's not a format string
43 | data.unshift(format);
44 | }
45 |
46 | data.forEach(function (item) {
47 | if (output) {
48 | output += ' ';
49 | }
50 | if (item && item.stack) {
51 | output += item.stack;
52 | } else {
53 | output += util.inspect(item);
54 | }
55 | });
56 |
57 | return output;
58 | }
59 |
60 | /**
61 | * Taken from masylum's fork (https://github.com/masylum/log4js-node)
62 | */
63 | function colorize (str, style) {
64 | var styles = {
65 | //styles
66 | 'bold' : [1, 22],
67 | 'italic' : [3, 23],
68 | 'underline' : [4, 24],
69 | 'inverse' : [7, 27],
70 | //grayscale
71 | 'white' : [37, 39],
72 | 'grey' : [90, 39],
73 | 'black' : [90, 39],
74 | //colors
75 | 'blue' : [34, 39],
76 | 'cyan' : [36, 39],
77 | 'green' : [32, 39],
78 | 'magenta' : [35, 39],
79 | 'red' : [31, 39],
80 | 'yellow' : [33, 39]
81 | };
82 | return style ? '\033[' + styles[style][0] + 'm' + str +
83 | '\033[' + styles[style][1] + 'm' : str;
84 | }
85 |
86 | function timestampLevelAndCategory(loggingEvent, colour) {
87 | var output = colorize(
88 | formatLogData(
89 | '[%s] [%s] %s - '
90 | , dateFormat.asString(loggingEvent.startTime)
91 | , loggingEvent.level
92 | , loggingEvent.categoryName
93 | )
94 | , colour
95 | );
96 | return output;
97 | }
98 |
99 | /**
100 | * BasicLayout is a simple layout for storing the logs. The logs are stored
101 | * in following format:
102 | *
103 | * [startTime] [logLevel] categoryName - message\n
104 | *
105 | *
106 | * @author Stephan Strittmatter
107 | */
108 | function basicLayout (loggingEvent) {
109 | return timestampLevelAndCategory(loggingEvent) + formatLogData(loggingEvent.data);
110 | }
111 |
112 | /**
113 | * colouredLayout - taken from masylum's fork.
114 | * same as basicLayout, but with colours.
115 | */
116 | function colouredLayout (loggingEvent) {
117 | return timestampLevelAndCategory(loggingEvent, colours[loggingEvent.level.toString()]) + formatLogData(loggingEvent.data);
118 | }
119 |
120 | function messagePassThroughLayout (loggingEvent) {
121 | return formatLogData(loggingEvent.data);
122 | }
123 |
124 | /**
125 | * PatternLayout
126 | * Format for specifiers is %[padding].[truncation][field]{[format]}
127 | * e.g. %5.10p - left pad the log level by 5 characters, up to a max of 10
128 | * Fields can be any of:
129 | * - %r time in toLocaleTimeString format
130 | * - %p log level
131 | * - %c log category
132 | * - %m log data
133 | * - %d date in various formats
134 | * - %% %
135 | * - %n newline
136 | * Takes a pattern string and returns a layout function.
137 | * @author Stephan Strittmatter
138 | */
139 | function patternLayout (pattern) {
140 | var TTCC_CONVERSION_PATTERN = "%r %p %c - %m%n";
141 | var regex = /%(-?[0-9]+)?(\.?[0-9]+)?([cdmnpr%])(\{([^\}]+)\})?|([^%]+)/;
142 |
143 | pattern = pattern || TTCC_CONVERSION_PATTERN;
144 |
145 | return function(loggingEvent) {
146 | var formattedString = "";
147 | var result;
148 | var searchString = pattern;
149 |
150 | while ((result = regex.exec(searchString))) {
151 | var matchedString = result[0];
152 | var padding = result[1];
153 | var truncation = result[2];
154 | var conversionCharacter = result[3];
155 | var specifier = result[5];
156 | var text = result[6];
157 |
158 | // Check if the pattern matched was just normal text
159 | if (text) {
160 | formattedString += "" + text;
161 | } else {
162 | // Create a raw replacement string based on the conversion
163 | // character and specifier
164 | var replacement = "";
165 | switch(conversionCharacter) {
166 | case "c":
167 | var loggerName = loggingEvent.categoryName;
168 | if (specifier) {
169 | var precision = parseInt(specifier, 10);
170 | var loggerNameBits = loggingEvent.categoryName.split(".");
171 | if (precision >= loggerNameBits.length) {
172 | replacement = loggerName;
173 | } else {
174 | replacement = loggerNameBits.slice(loggerNameBits.length - precision).join(".");
175 | }
176 | } else {
177 | replacement = loggerName;
178 | }
179 | break;
180 | case "d":
181 | var format = dateFormat.ISO8601_FORMAT;
182 | if (specifier) {
183 | format = specifier;
184 | // Pick up special cases
185 | if (format == "ISO8601") {
186 | format = dateFormat.ISO8601_FORMAT;
187 | } else if (format == "ABSOLUTE") {
188 | format = dateFormat.ABSOLUTETIME_FORMAT;
189 | } else if (format == "DATE") {
190 | format = dateFormat.DATETIME_FORMAT;
191 | }
192 | }
193 | // Format the date
194 | replacement = dateFormat.asString(format, loggingEvent.startTime);
195 | break;
196 | case "m":
197 | replacement = formatLogData(loggingEvent.data);
198 | break;
199 | case "n":
200 | replacement = "\n";
201 | break;
202 | case "p":
203 | replacement = loggingEvent.level.toString();
204 | break;
205 | case "r":
206 | replacement = "" + loggingEvent.startTime.toLocaleTimeString();
207 | break;
208 | case "%":
209 | replacement = "%";
210 | break;
211 | default:
212 | replacement = matchedString;
213 | break;
214 | }
215 | // Format the replacement according to any padding or
216 | // truncation specified
217 |
218 | var len;
219 |
220 | // First, truncation
221 | if (truncation) {
222 | len = parseInt(truncation.substr(1), 10);
223 | replacement = replacement.substring(0, len);
224 | }
225 | // Next, padding
226 | if (padding) {
227 | if (padding.charAt(0) == "-") {
228 | len = parseInt(padding.substr(1), 10);
229 | // Right pad with spaces
230 | while (replacement.length < len) {
231 | replacement += " ";
232 | }
233 | } else {
234 | len = parseInt(padding, 10);
235 | // Left pad with spaces
236 | while (replacement.length < len) {
237 | replacement = " " + replacement;
238 | }
239 | }
240 | }
241 | formattedString += replacement;
242 | }
243 | searchString = searchString.substr(result.index + result[0].length);
244 | }
245 | return formattedString;
246 | };
247 |
248 | };
249 |
250 |
251 | module.exports = {
252 | basicLayout: basicLayout
253 | , messagePassThroughLayout: messagePassThroughLayout
254 | , patternLayout: patternLayout
255 | , colouredLayout: colouredLayout
256 | , coloredLayout: colouredLayout
257 | , layout: function(name, config) {
258 | return layoutMakers[name] && layoutMakers[name](config);
259 | }
260 | };
--------------------------------------------------------------------------------
/node_modules/log4js/lib/levels.js:
--------------------------------------------------------------------------------
1 | function Level(level, levelStr) {
2 | this.level = level;
3 | this.levelStr = levelStr;
4 | }
5 |
6 | /**
7 | * converts given String to corresponding Level
8 | * @param {String} sArg String value of Level
9 | * @param {Log4js.Level} defaultLevel default Level, if no String representation
10 | * @return Level object
11 | * @type Log4js.Level
12 | */
13 | function toLevel(sArg, defaultLevel) {
14 |
15 | if (sArg === null) {
16 | return defaultLevel;
17 | }
18 |
19 | if (typeof sArg == "string") {
20 | var s = sArg.toUpperCase();
21 | if (module.exports[s]) {
22 | return module.exports[s];
23 | }
24 | }
25 | return defaultLevel;
26 | };
27 |
28 | Level.prototype.toString = function() {
29 | return this.levelStr;
30 | };
31 |
32 | Level.prototype.isLessThanOrEqualTo = function(otherLevel) {
33 | if (typeof otherLevel === "string") {
34 | otherLevel = toLevel(otherLevel);
35 | }
36 | return this.level <= otherLevel.level;
37 | };
38 |
39 | Level.prototype.isGreaterThanOrEqualTo = function(otherLevel) {
40 | if (typeof otherLevel === "string") {
41 | otherLevel = toLevel(otherLevel);
42 | }
43 | return this.level >= otherLevel.level;
44 | };
45 |
46 | module.exports = {
47 | ALL: new Level(Number.MIN_VALUE, "ALL")
48 | , TRACE: new Level(5000, "TRACE")
49 | , DEBUG: new Level(10000, "DEBUG")
50 | , INFO: new Level(20000, "INFO")
51 | , WARN: new Level(30000, "WARN")
52 | , ERROR: new Level(40000, "ERROR")
53 | , FATAL: new Level(50000, "FATAL")
54 | , OFF: new Level(Number.MAX_VALUE, "OFF")
55 | , toLevel: toLevel
56 | };
57 |
--------------------------------------------------------------------------------
/node_modules/log4js/lib/log4js.json:
--------------------------------------------------------------------------------
1 | {
2 | "appenders": [
3 | {
4 | "type": "console"
5 | }
6 | ]
7 | }
--------------------------------------------------------------------------------
/node_modules/log4js/lib/streams.js:
--------------------------------------------------------------------------------
1 | var util = require('util'),
2 | fs = require('fs'),
3 | path = require('path'),
4 | events = require('events'),
5 | async = require('async');
6 |
7 | function debug(message) {
8 | util.debug(message);
9 | // console.log(message);
10 | }
11 |
12 | function BufferedWriteStream(stream) {
13 | var that = this;
14 | this.stream = stream;
15 | this.buffer = [];
16 | this.canWrite = false;
17 | this.bytes = 0;
18 |
19 | this.stream.on("open", function() {
20 | that.canWrite = true;
21 | that.flushBuffer();
22 | });
23 |
24 | this.stream.on("error", function (err) {
25 | that.emit("error", err);
26 | });
27 |
28 | this.stream.on("drain", function() {
29 | that.canWrite = true;
30 | that.flushBuffer();
31 | });
32 | }
33 |
34 | util.inherits(BufferedWriteStream, events.EventEmitter);
35 |
36 | Object.defineProperty(
37 | BufferedWriteStream.prototype,
38 | "fd",
39 | {
40 | get: function() { return this.stream.fd; },
41 | set: function(newFd) {
42 | this.stream.fd = newFd;
43 | this.bytes = 0;
44 | }
45 | }
46 | );
47 |
48 | Object.defineProperty(
49 | BufferedWriteStream.prototype,
50 | "bytesWritten",
51 | {
52 | get: function() { return this.bytes; }
53 | }
54 | );
55 |
56 | BufferedWriteStream.prototype.write = function(data, encoding) {
57 | this.buffer.push({ data: data, encoding: encoding });
58 | this.flushBuffer();
59 | };
60 |
61 | BufferedWriteStream.prototype.end = function(data, encoding) {
62 | if (data) {
63 | this.buffer.push({ data: data, encoding: encoding });
64 | }
65 | this.flushBufferEvenIfCannotWrite();
66 | };
67 |
68 | BufferedWriteStream.prototype.writeToStream = function(toWrite) {
69 | this.bytes += toWrite.data.length;
70 | this.canWrite = this.stream.write(toWrite.data, toWrite.encoding);
71 | };
72 |
73 | BufferedWriteStream.prototype.flushBufferEvenIfCannotWrite = function() {
74 | while (this.buffer.length > 0) {
75 | this.writeToStream(this.buffer.shift());
76 | }
77 | };
78 |
79 | BufferedWriteStream.prototype.flushBuffer = function() {
80 | while (this.buffer.length > 0 && this.canWrite) {
81 | this.writeToStream(this.buffer.shift());
82 | }
83 | };
84 |
85 | function BaseRollingFileStream(filename, options) {
86 | this.filename = filename;
87 | this.options = options || { encoding: 'utf8', mode: 0644, flags: 'a' };
88 | this.rolling = false;
89 | this.writesWhileRolling = [];
90 | this.currentSize = 0;
91 |
92 | function currentFileSize(file) {
93 | var fileSize = 0;
94 | try {
95 | fileSize = fs.statSync(file).size;
96 | } catch (e) {
97 | // file does not exist
98 | }
99 | return fileSize;
100 | }
101 |
102 | function throwErrorIfArgumentsAreNotValid() {
103 | if (!filename) {
104 | throw new Error("You must specify a filename");
105 | }
106 | }
107 |
108 | throwErrorIfArgumentsAreNotValid();
109 |
110 | BaseRollingFileStream.super_.call(this, this.filename, this.options);
111 | this.currentSize = currentFileSize(this.filename);
112 | }
113 | util.inherits(BaseRollingFileStream, fs.FileWriteStream);
114 |
115 | BaseRollingFileStream.prototype.initRolling = function() {
116 | var that = this;
117 |
118 | function emptyRollingQueue() {
119 | debug("emptying the rolling queue");
120 | var toWrite;
121 | while ((toWrite = that.writesWhileRolling.shift())) {
122 | BaseRollingFileStream.super_.prototype.write.call(that, toWrite.data, toWrite.encoding);
123 | that.currentSize += toWrite.data.length;
124 | if (that.shouldRoll()) {
125 | that.flush();
126 | return true;
127 | }
128 | }
129 | that.flush();
130 | return false;
131 | }
132 |
133 | this.rolling = true;
134 | this.roll(this.filename, function() {
135 | that.currentSize = 0;
136 | that.rolling = emptyRollingQueue();
137 | if (that.rolling) {
138 | process.nextTick(function() { that.initRolling(); });
139 | }
140 | });
141 | };
142 |
143 | BaseRollingFileStream.prototype.write = function(data, encoding) {
144 | if (this.rolling) {
145 | this.writesWhileRolling.push({ data: data, encoding: encoding });
146 | return false;
147 | } else {
148 | var canWrite = BaseRollingFileStream.super_.prototype.write.call(this, data, encoding);
149 | this.currentSize += data.length;
150 | debug('current size = ' + this.currentSize);
151 | if (this.shouldRoll()) {
152 | this.initRolling();
153 | }
154 | return canWrite;
155 | }
156 | };
157 |
158 | BaseRollingFileStream.prototype.shouldRoll = function() {
159 | return false; // default behaviour is never to roll
160 | };
161 |
162 | BaseRollingFileStream.prototype.roll = function(filename, callback) {
163 | callback(); // default behaviour is not to do anything
164 | };
165 |
166 |
167 | function RollingFileStream (filename, size, backups, options) {
168 | this.size = size;
169 | this.backups = backups || 1;
170 |
171 | function throwErrorIfArgumentsAreNotValid() {
172 | if (!filename || !size || size <= 0) {
173 | throw new Error("You must specify a filename and file size");
174 | }
175 | }
176 |
177 | throwErrorIfArgumentsAreNotValid();
178 |
179 | RollingFileStream.super_.call(this, filename, options);
180 | }
181 | util.inherits(RollingFileStream, BaseRollingFileStream);
182 |
183 | RollingFileStream.prototype.shouldRoll = function() {
184 | return this.currentSize >= this.size;
185 | };
186 |
187 | RollingFileStream.prototype.roll = function(filename, callback) {
188 | var that = this,
189 | nameMatcher = new RegExp('^' + path.basename(filename));
190 |
191 | function justTheseFiles (item) {
192 | return nameMatcher.test(item);
193 | }
194 |
195 | function index(filename_) {
196 | return parseInt(filename_.substring((path.basename(filename) + '.').length), 10) || 0;
197 | }
198 |
199 | function byIndex(a, b) {
200 | if (index(a) > index(b)) {
201 | return 1;
202 | } else if (index(a) < index(b) ) {
203 | return -1;
204 | } else {
205 | return 0;
206 | }
207 | }
208 |
209 | function increaseFileIndex (fileToRename, cb) {
210 | var idx = index(fileToRename);
211 | debug('Index of ' + fileToRename + ' is ' + idx);
212 | if (idx < that.backups) {
213 | //on windows, you can get a EEXIST error if you rename a file to an existing file
214 | //so, we'll try to delete the file we're renaming to first
215 | fs.unlink(filename + '.' + (idx+1), function (err) {
216 | //ignore err: if we could not delete, it's most likely that it doesn't exist
217 | debug('Renaming ' + fileToRename + ' -> ' + filename + '.' + (idx+1));
218 | fs.rename(path.join(path.dirname(filename), fileToRename), filename + '.' + (idx + 1), cb);
219 | });
220 | } else {
221 | cb();
222 | }
223 | }
224 |
225 | function renameTheFiles(cb) {
226 | //roll the backups (rename file.n to file.n+1, where n <= numBackups)
227 | debug("Renaming the old files");
228 | fs.readdir(path.dirname(filename), function (err, files) {
229 | async.forEachSeries(
230 | files.filter(justTheseFiles).sort(byIndex).reverse(),
231 | increaseFileIndex,
232 | cb
233 | );
234 | });
235 | }
236 |
237 | function openANewFile(cb) {
238 | debug("Opening a new file");
239 | fs.open(
240 | filename,
241 | that.options.flags,
242 | that.options.mode,
243 | function (err, fd) {
244 | debug("opened new file");
245 | var oldLogFileFD = that.fd;
246 | that.fd = fd;
247 | that.writable = true;
248 | fs.close(oldLogFileFD, cb);
249 | }
250 | );
251 | }
252 |
253 | debug("Starting roll");
254 | debug("Queueing up data until we've finished rolling");
255 | debug("Flushing underlying stream");
256 | this.flush();
257 |
258 | async.series([
259 | renameTheFiles,
260 | openANewFile
261 | ], callback);
262 |
263 | };
264 |
265 |
266 | exports.BaseRollingFileStream = BaseRollingFileStream;
267 | exports.RollingFileStream = RollingFileStream;
268 | exports.BufferedWriteStream = BufferedWriteStream;
269 |
--------------------------------------------------------------------------------
/node_modules/log4js/log-rolling.js:
--------------------------------------------------------------------------------
1 | var log4js = require('./lib/log4js')
2 | , log
3 | , i = 0;
4 | log4js.configure({
5 | "appenders": [
6 | {
7 | type: "console"
8 | , category: "console"
9 | },
10 | {
11 | "type": "file",
12 | "filename": "tmp-test.log",
13 | "maxLogSize": 1024,
14 | "backups": 3,
15 | "category": "test"
16 | }
17 | ]
18 | });
19 | log = log4js.getLogger("test");
20 |
21 | function doTheLogging(x) {
22 | log.info("Logging something %d", x);
23 | }
24 |
25 | for ( ; i < 5000; i++) {
26 | doTheLogging(i);
27 | }
--------------------------------------------------------------------------------
/node_modules/log4js/memory-test.js:
--------------------------------------------------------------------------------
1 | var log4js = require('./lib/log4js')
2 | , logger
3 | , usage
4 | , i;
5 |
6 | log4js.configure(
7 | {
8 | appenders: [
9 | {
10 | category: "memory-test"
11 | , type: "file"
12 | , filename: "memory-test.log"
13 | },
14 | {
15 | type: "console"
16 | , category: "memory-usage"
17 | },
18 | {
19 | type: "file"
20 | , filename: "memory-usage.log"
21 | , category: "memory-usage"
22 | , layout: {
23 | type: "messagePassThrough"
24 | }
25 | }
26 | ]
27 | }
28 | );
29 | logger = log4js.getLogger("memory-test");
30 | usage = log4js.getLogger("memory-usage");
31 |
32 | for (i=0; i < 1000000; i++) {
33 | if ( (i % 5000) === 0) {
34 | usage.info("%d %d", i, process.memoryUsage().rss);
35 | }
36 | logger.info("Doing something.");
37 | }
38 |
--------------------------------------------------------------------------------
/node_modules/log4js/node_modules/async/.gitmodules:
--------------------------------------------------------------------------------
1 | [submodule "deps/nodeunit"]
2 | path = deps/nodeunit
3 | url = git://github.com/caolan/nodeunit.git
4 | [submodule "deps/UglifyJS"]
5 | path = deps/UglifyJS
6 | url = https://github.com/mishoo/UglifyJS.git
7 | [submodule "deps/nodelint"]
8 | path = deps/nodelint
9 | url = https://github.com/tav/nodelint.git
10 |
--------------------------------------------------------------------------------
/node_modules/log4js/node_modules/async/LICENSE:
--------------------------------------------------------------------------------
1 | Copyright (c) 2010 Caolan McMahon
2 |
3 | Permission is hereby granted, free of charge, to any person obtaining a copy
4 | of this software and associated documentation files (the "Software"), to deal
5 | in the Software without restriction, including without limitation the rights
6 | to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
7 | copies of the Software, and to permit persons to whom the Software is
8 | furnished to do so, subject to the following conditions:
9 |
10 | The above copyright notice and this permission notice shall be included in
11 | all copies or substantial portions of the Software.
12 |
13 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
14 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
15 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
16 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
17 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
18 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
19 | THE SOFTWARE.
20 |
--------------------------------------------------------------------------------
/node_modules/log4js/node_modules/async/Makefile:
--------------------------------------------------------------------------------
1 | PACKAGE = asyncjs
2 | NODEJS = $(if $(shell test -f /usr/bin/nodejs && echo "true"),nodejs,node)
3 |
4 | BUILDDIR = dist
5 |
6 | all: build
7 |
8 | build: $(wildcard lib/*.js)
9 | mkdir -p $(BUILDDIR)
10 | uglifyjs lib/async.js > $(BUILDDIR)/async.min.js
11 |
12 | test:
13 | nodeunit test
14 |
15 | clean:
16 | rm -rf $(BUILDDIR)
17 |
18 | lint:
19 | nodelint --config nodelint.cfg lib/async.js
20 |
21 | .PHONY: test build all
22 |
--------------------------------------------------------------------------------
/node_modules/log4js/node_modules/async/deps/nodeunit.css:
--------------------------------------------------------------------------------
1 | /*!
2 | * Styles taken from qunit.css
3 | */
4 |
5 | h1#nodeunit-header, h1.nodeunit-header {
6 | padding: 15px;
7 | font-size: large;
8 | background-color: #06b;
9 | color: white;
10 | font-family: 'trebuchet ms', verdana, arial;
11 | margin: 0;
12 | }
13 |
14 | h1#nodeunit-header a {
15 | color: white;
16 | }
17 |
18 | h2#nodeunit-banner {
19 | height: 2em;
20 | border-bottom: 1px solid white;
21 | background-color: #eee;
22 | margin: 0;
23 | font-family: 'trebuchet ms', verdana, arial;
24 | }
25 | h2#nodeunit-banner.pass {
26 | background-color: green;
27 | }
28 | h2#nodeunit-banner.fail {
29 | background-color: red;
30 | }
31 |
32 | h2#nodeunit-userAgent, h2.nodeunit-userAgent {
33 | padding: 10px;
34 | background-color: #eee;
35 | color: black;
36 | margin: 0;
37 | font-size: small;
38 | font-weight: normal;
39 | font-family: 'trebuchet ms', verdana, arial;
40 | font-size: 10pt;
41 | }
42 |
43 | div#nodeunit-testrunner-toolbar {
44 | background: #eee;
45 | border-top: 1px solid black;
46 | padding: 10px;
47 | font-family: 'trebuchet ms', verdana, arial;
48 | margin: 0;
49 | font-size: 10pt;
50 | }
51 |
52 | ol#nodeunit-tests {
53 | font-family: 'trebuchet ms', verdana, arial;
54 | font-size: 10pt;
55 | }
56 | ol#nodeunit-tests li strong {
57 | cursor:pointer;
58 | }
59 | ol#nodeunit-tests .pass {
60 | color: green;
61 | }
62 | ol#nodeunit-tests .fail {
63 | color: red;
64 | }
65 |
66 | p#nodeunit-testresult {
67 | margin-left: 1em;
68 | font-size: 10pt;
69 | font-family: 'trebuchet ms', verdana, arial;
70 | }
71 |
--------------------------------------------------------------------------------
/node_modules/log4js/node_modules/async/dist/async.min.js:
--------------------------------------------------------------------------------
1 | /*global setTimeout: false, console: false */(function(){var a={},b=this,c=b.async;typeof module!="undefined"&&module.exports?module.exports=a:b.async=a,a.noConflict=function(){return b.async=c,a};var d=function(a,b){if(a.forEach)return a.forEach(b);for(var c=0;cd?1:0};d(null,e(b.sort(c),function(a){return a.value}))})},a.auto=function(a,b){b=b||function(){};var c=g(a);if(!c.length)return b(null);var e={},h=[],i=function(a){h.unshift(a)},j=function(a){for(var b=0;b
2 |
3 | Async.js Test Suite
4 |
8 |
9 |
10 |