Coverage

92%

359

332

master.js

92%

230

212

Line	Hits	Source
1		/* vim: set expandtab tabstop=2 shiftwidth=2 foldmethod=marker: */
2
3	2	var fs = require('fs');
4	2	var util = require('util');
5	2	var Emitter = require('events').EventEmitter;
6	2	var child_process = require('child_process');
7
8	2	var common = require('./common');
9	2	var STATUS = common.STATUS;
10	2	var MESSAGE = common.MESSAGE;
11	2	var debug = common.debug;
12	2	var listen = common.listen;
13	2	var MAX_HEARTBEAT_INTERVAL = common.MAX_HEARTBEAT_INTERVAL;
14
15	2	var NOTICE = function (name, message) {
16	4	debug('master', Array.prototype.join.call(arguments, ' '));
17		};
18
19	2	var WRITE_STATUS_FILE = function (name, pid, message) {
20		};
21
22		/* {{{ private function _normalize() */
23	2	var _normalize = function (name) {
24	5	return name.toString().trim().toLowerCase();
25		};
26		/* }}} */
27
28	2	var _workerPair = function (argv, options, name) {
29
30		/**
31		* @ _options
32		*/
33	3	var _options = {
34		'listen' : [],
35		'children' : require('os').cpus().length,
36		'max_request' : 0,
37		'max_fatal_restart': 5,
38		};
39	3	var groupName = name;
40
41		/* {{{ options rewrite */
42
43	3	for (var k in options) {
44	6	var value = options[k];
45	6	switch (k) {
46		case 'listen':
47	3	_options[k] = Array.isArray(value) ? value : [value];
48	3	break;
49		default:
50	3	_options[k] = value;
51	3	break;
52		}
53		}
54		/* }}} */
55
56		/**
57		* @ è¯·æ±éå
58		*/
59	3	var _fdqueue = [];
60
61		/**
62		* @ åè¿ç¨åè¡¨
63		*/
64	3	var _pobject = [];
65
66		/**
67		* @ åè¿ç¨ç¶æ
68		*/
69	3	var _pstatus = {};
70
71	3	var _killall = function (signal) {
72	6	_pobject.forEach(function (sub) {
73	12	try {
74	12	sub.kill(signal \|\| 'SIGTERM');
75		} catch (e) {
76		}
77		});
78	6	_pobject = [];
79		};
80
81		/**
82		* @ fatal restarts
83		*/
84	3	var _fatals = [];
85
86		/* {{{ function _newChild() */
87		/**
88		* fork a new child process
89		* @return {Object} child_process
90		*/
91	3	var _command = argv.join(' ');
92	3	var _execpath = argv.shift();
93	3	var _newChild = function () {
94
95	34	var sub = child_process.fork(_execpath, argv, {
96		'cwd' : process.cwd(),
97		'env' : process.env,
98		});
99	34	var pid = sub.pid;
100
101	34	_pobject.push(sub);
102	34	_pstatus[pid] = {
103		'status' : STATUS.UNKNOWN,
104		};
105
106	34	NOTICE(util.format('new worker forked (%d) as "%s"', pid, _command));
107
108		/**
109		* @ on exit
110		*/
111		/* {{{ */
112	34	sub.on('exit', function (code, signal) {
113	16	var _objects = [];
114	16	_pobject.forEach(function (item) {
115	69	if (item.pid !== pid) {
116	55	_objects.push(item);
117		}
118		});
119	16	_pobject = _objects;
120	16	delete _pstatus[pid];
121
122	16	if (STATUS.STOPING === _wstatus) {
123	2	return;
124		}
125
126	14	if (code && 'SIGKILL' !== signal) {
127	6	var now = Date.now();
128	6	if (_fatals.unshift(now) > _options.max_fatal_restart) {
129	1	_fatals = _fatals.slice(0, _options.max_fatal_restart);
130		}
131
132	6	if (_fatals.length >= _options.max_fatal_restart && _fatals[_fatals.length - 1] + 60000 >= now) {
133	2	NOTICE('max fatal restarts (' + _options.max_fatal_restart + ') arrived, give up to fork');
134
135	2	__GLOBAL_MASTER.emit('giveup', groupName, _fatals.length);
136		// after 1 minute, start again
137	2	setTimeout(function () {
138	0	_me.start();
139		}, 60100);
140
141	2	return;
142		}
143		}
144	12	_me.start();
145		});
146		/* }}} */
147
148		/**
149		* @on message
150		*/
151		/* {{{ */
152	34	var _send = function (type, data, handle, port) {
153	6	try {
154	6	sub.send({
155		'type' : type,
156		'data' : data,
157		'port' : port
158		}, handle);
159		} catch (e) {
160	0	NOTICE('SEND', e.stack);
161		}
162		};
163
164	34	sub.on('message', function (msg) {
165	43	if (!msg \|\| !msg.type) {
166	16	return;
167		}
168
169	27	switch (msg.type) {
170		case MESSAGE.GET_FD:
171	6	var _item = _fdqueue.shift();
172	6	if (!_item) {
173	2	_send(MESSAGE.REQ_FD, 0);
174	2	break;
175		}
176	4	var _fd = _item[1];
177	4	_send(MESSAGE.REQ_FD, _fdqueue.length, _fd, _item[0]);
178	4	_fd.close();
179	4	_fd = null;
180	4	break;
181
182		case MESSAGE.STATUS:
183	13	var pstat = _pstatus[pid] = msg.data;
184	13	pstat._time = Date.now();
185	13	WRITE_STATUS_FILE(groupName, pid, pstat);
186	13	_check_stat_change();
187	13	if (_options.max_request && pstat.scores > _options.max_request) {
188	4	_newChild();
189	4	_tobekill.push(pid);
190		}
191	13	break;
192
193		case MESSAGE.RELOAD:
194	1	if (msg.data) {
195	1	var gname = _normalize(msg.data.name \|\| groupName);
196	1	if (__WORKERS_LIST[gname]) {
197	1	__WORKERS_LIST[gname].reload();
198		}
199		}
200	1	break;
201
202		case MESSAGE.SENDTO:
203	3	if (msg.data && msg.data.name && msg.data.data) {
204	1	var gname = _normalize(msg.data.name);
205	1	if (__WORKERS_LIST[gname]) {
206		// TODO: gname or groupName?
207	1	__WORKERS_LIST[gname].accept(msg.data.data, groupName, pid);
208		}
209		}
210	3	break;
211
212		default:
213	4	break;
214		}
215		});
216		/* }}} */
217
218	34	return sub;
219
220		};
221		/* }}} */
222
223	3	var _running = 0;
224
225		/* {{{ */
226	3	var _check_stat_change = function () {
227	13	var _floor = _options.children / 2;
228	13	var _count = 0;
229	13	for (var i in _pstatus) {
230	53	var _stat = _pstatus[i];
231	53	if (STATUS.RUNNING === _stat.status /** && _stat._time >= ? */) {
232	31	_count++;
233		}
234		}
235	13	if (_count !== _running) {
236	9	__GLOBAL_MASTER.emit('state', groupName, _count, _running);
237		}
238
239	13	_running = _count;
240	13	if (_running >= _floor) {
241	12	_tobekill.forEach(function (pid) {
242	8	process.kill(pid, 'SIGTERM');
243		});
244	12	_tobekill = [];
245		}
246		};
247		/* }}} */
248
249		/**
250		* @process object
251		*/
252	3	var _wakeups = 0;
253
254		/**
255		* @to be killed process
256		*/
257	3	var _tobekill = [];
258
259		/**
260		* @listeners
261		*/
262	3	var _listener = {};
263
264		/**
265		* @worker status
266		*/
267	3	var _wstatus = STATUS.PENDING;
268
269		/**
270		* @timer to check heartbeat
271		*/
272		/* {{{ */
273	3	var _timer = setInterval(function () {
274	0	var _expire = Date.now() - MAX_HEARTBEAT_INTERVAL;
275	0	for (var pid in _pstatus) {
276	0	var _stat = _pstatus[pid];
277		// `MAX_HEARTBEAT_INTERVAL` no heartbeat, kill the worker
278	0	if (_stat._time < _expire) {
279	0	_newChild();
280	0	_tobekill.push(pid);
281		}
282		}
283		}, 2000);
284
285		/* }}} */
286
287	3	var _me = {};
288
289		/* {{{ public function start() */
290	3	_me.start = function () {
291	16	_wstatus = STATUS.PENDING;
292	16	for (var i = _pobject.length; i < _options.children; i++) {
293	11	_newChild();
294		}
295
296	16	var usepush = 2 * _options.children;
297	16	_options.listen.forEach(function (item) {
298	17	if (_listener[item]) {
299	13	return;
300		}
301	4	_listener[item] = listen(item, function (handle, port) {
302	4	if (_fdqueue.push([port, handle]) <= usepush) {
303	4	_wakeups = (_wakeups + 1) % _pobject.length;
304	4	try {
305	4	_pobject[_wakeups].send({
306		'type' : MESSAGE.WAKEUP,
307		});
308		} catch (e) {
309		}
310		}
311		});
312		});
313		};
314	3	_me.start();
315		/* }}} */
316
317		/* {{{ public function stop() */
318		/**
319		* stop worker process
320		*/
321	3	_me.stop = function (callback, signal) {
322	6	_wstatus = STATUS.STOPING;
323	6	for (var idx in _listener) {
324	4	var _fd = _listener[idx];
325	4	_fd.close();
326	4	_fd = null;
327		}
328	6	_listener = {};
329	6	_killall(signal);
330
331	6	callback && callback();
332
333		// var _timer1, _timer2;
334		// _timer1 = setTimeout(function () {
335		// _killall(signal);
336		// clearInterval(_timer2);
337		// }, 1000);
338
339		// _timer2 = setInterval(function () {
340		// if (0 === _fdqueue.length) {
341		// _killall(signal);
342		// clearTimeout(_timer1);
343		// clearInterval(_timer2);
344		// }
345		// }, 20);
346		};
347		/* }}} */
348
349		/* {{{ public function reload() */
350	3	_me.reload = function () {
351	5	for (var pid in _pstatus) {
352	19	_newChild();
353	19	pid = parseInt(pid, 10);
354	19	if (pid) {
355	19	_tobekill.push(pid);
356		}
357		}
358		};
359		/* }}} */
360
361		/* {{{ public function accept() */
362	3	_me.accept = function (data, from, pid) {
363	1	_pobject.forEach(function (sub) {
364	4	try {
365	4	sub.send({
366		'type' : MESSAGE.COMMAND,
367		'data' : data,
368		'from' : from,
369		'pid' : pid,
370		});
371		} catch (e) {
372	0	NOTICE('SEND', e.stack);
373		}
374		});
375		};
376		/* }}} */
377
378	3	return _me;
379
380		};
381
382		/* {{{ function _createPidFile() */
383	2	var _createPidFile = function (fname) {
384	2	var pid = String(process.pid);
385	2	fs.writeFile(fname, pid, function (error) {
386	2	if (error) {
387	0	throw error;
388		}
389		});
390
391	2	process.on('exit', function () {
392	0	try {
393	0	if (pid !== fs.readFileSync(fname, 'utf-8').trim()) {
394	0	return;
395		}
396	0	fs.unlinkSync(fname);
397		} catch (e) {
398		}
399		});
400		};
401		/* }}} */
402
403		/* {{{ Master constructor */
404
405	2	var Master = function (options) {
406	2	if (!(this instanceof Master)) {
407	0	return new Master();
408		}
409
410	2	if (options.pidfile) {
411	2	_createPidFile(options.pidfile);
412		}
413
414	2	if (options.statusfile) {
415	2	WRITE_STATUS_FILE = function (name, pid, message) {
416	13	fs.createWriteStream(options.statusfile, {
417		flags: 'a+',
418		encoding: 'utf-8',
419		mode: 0644
420		}).end(util.format(
421		'%d:\t%s\t%d\t%j\n', process.pid, name, pid, message
422		));
423		};
424
425		// XXX: fork
426		}
427
428	2	Emitter.call(this);
429		};
430	2	util.inherits(Master, Emitter);
431
432		/* }}} */
433
434	2	var __WORKERS_LIST = {};
435	2	var __GLOBAL_MASTER = null;
436
437		/**
438		* Register a group of workers.
439		* @param {String} name
440		* @param {String} file, worker file path.
441		* @param {Object} options
442		* - {Array\|Number\|String} listen, listen port or domain sock, e.g.: `80`, `[80, 8080]` or `[80, '/tmp/web.sock']`.
443		* - {Number} [children], worker number, default is `os.cpu` number.
444		* - {Number} [max_request], max request number per child worker. Dafault is `0`, no limit.
445		* - {Number} [max_fatal_restart], max fatal to giveup restart. Dafault is `5`.
446		* - {Bool} [trace_gc], trace gc, default is `false`.
447		* @param {Array} [argv] process start argv.
448		* @api public
449		*/
450	2	Master.prototype.register = function (name, file, options, argv) {
451	3	name = _normalize(name);
452	3	if (__WORKERS_LIST[name]) {
453	0	__WORKERS_LIST[name].stop(function () {
454		}, 'SIGKILL');
455		}
456
457	3	argv = Array.isArray(argv) ? argv : [];
458	3	argv.unshift(file);
459
460	3	if (options.trace_gc) {
461	0	argv.unshift('--trace_gc');
462	0	delete options.trace_gc;
463		}
464
465	3	__WORKERS_LIST[name] = _workerPair(argv, options, name);
466	3	return this;
467		};
468
469	2	Master.prototype.shutdown = function (callback, signal, name) {
470	7	if (name) {
471	4	if (__WORKERS_LIST[name]) {
472	3	__WORKERS_LIST[name].stop(callback, signal);
473		} else {
474	1	callback && callback();
475		}
476		} else {
477	3	for (var k in __WORKERS_LIST) {
478	3	__WORKERS_LIST[k].stop(null, signal);
479		}
480	3	callback && callback();
481		}
482	7	return this;
483		};
484
485	2	Master.prototype.reload = function (name) {
486	4	if (name) {
487	2	if (__WORKERS_LIST[name]) {
488	2	__WORKERS_LIST[name].reload();
489		}
490		} else {
491	2	for (var k in __WORKERS_LIST) {
492	2	__WORKERS_LIST[k].reload();
493		}
494		}
495	4	return this;
496		};
497
498	2	Master.prototype.dispatch = function () {
499	1	for (var name in __WORKERS_LIST) {
500	1	__WORKERS_LIST[name].start();
501		}
502	1	return this;
503		};
504
505	2	exports.create = function (options) {
506
507	3	if (!__GLOBAL_MASTER) {
508	2	__GLOBAL_MASTER = new Master(options);
509
510	2	process.on('SIGHUB', function () {});
511	2	process.on('exit', function () {
512	1	NOTICE('About to exit ...');
513	1	__GLOBAL_MASTER.shutdown(function () {
514	1	NOTICE('SIGKILL exited');
515		}, 'SIGKILL');
516		});
517
518	2	process.on('SIGTERM', function () {
519	1	NOTICE('Got SIGTERM, about to exit...');
520	1	__GLOBAL_MASTER.shutdown(function () {
521	1	NOTICE('SIGTERM exited');
522		});
523		});
524
525	2	process.on('SIGUSR1', function () {
526	1	NOTICE('Got SIGUSR1, about to reload...');
527	1	__GLOBAL_MASTER.reload();
528		});
529		}
530
531	3	return __GLOBAL_MASTER;
532
533		};
534

common.js

100%

Line	Hits	Source
1		/* vim: set expandtab tabstop=2 shiftwidth=2 foldmethod=marker: */
2
3	2	exports.MAX_HEARTBEAT_INTERVAL = 30000;
4
5		/**
6		* @è¿ç¨ç¶ææº
7		*/
8	2	exports.STATUS = {
9		'UNKNOWN' : 0, /*< æªç¥ç¶æ /
10		'PENDING' : 1, /*< åå¤ç¶æ /
11		'RUNNING' : 2, /*< å¯æ¥åæå¡ /
12		'STOPING' : 3, /*< åå¤å³é /
13		};
14
15		/**
16		* @æ¶æ¯ç±»å
17		*/
18	2	exports.MESSAGE = {
19		'GET_FD' : 11, /*< è·åå¥æ (worker -> master) /
20		'REQ_FD' : 12, /*< è¯·æ±å¥æ (master -> worker) /
21		'WAKEUP' : 14, /*< å¤éæ¶æ¯ (master -> worker) /
22		'LISTEN' : 16, /*< çå¬ç«¯å£ (master -> worker) /
23		'STATUS' : 21, /*< ç¶ææ¥å (worker -> master) /
24		'RELOAD' : 23, /*< éè½½è¿ç¨ (worker -> master) /
25		'SENDTO' : 31, /*< è½¬åæ¶æ¯ (worker -> master) /
26		'COMMAND' : 32, /*< å½ä»¤æ¶æ¯ (master -> worker) /
27		};
28
29		/**
30		* @æå°æ¥å¿
31		*/
32	2	exports.debug = function (name, message) {
33	7	console.log('[' + (name \|\| 'unknown') + ':' + process.pid + '][' + new Date() + '] ' + message);
34		};
35
36		/**
37		* @çå¬ç«¯å£æèsocket
38		*/
39		/* {{{ public function listen() */
40
41	2	var __tcpError = function (name, message) {
42	3	var error = new Error(message \|\| 'unknown');
43	3	error.name = name;
44	3	return error;
45		};
46
47	2	var TCP = process.binding('tcp_wrap').TCP;
48	2	var Pipe = process.binding('pipe_wrap').Pipe;
49	2	exports.listen = function (portOrSock, connection) {
50	10	portOrSock = /^\d+$/.test(portOrSock) ? Number(portOrSock) : portOrSock;
51	10	var _me;
52	10	var ret;
53	10	if (typeof portOrSock === 'number') {
54	7	_me = new TCP();
55	7	ret = _me.bind('0.0.0.0', portOrSock);
56		} else {
57	3	_me = new Pipe();
58	3	ret = _me.bind(portOrSock);
59		}
60
61	10	if (ret) {
62		// if `ret` is not zero, bind error.
63	2	_me.close();
64	2	_me = null;
65	2	throw __tcpError('BIND', 'Can not bind to ' + portOrSock);
66		}
67
68	8	if (_me.listen(1023)) {
69	1	_me.close();
70	1	_me = null;
71	1	throw __tcpError('LISTEN', 'Can not listen at ' + portOrSock);
72		}
73
74	7	_me.onconnection = function (handle) {
75	7	connection(handle, portOrSock);
76		};
77
78	7	return _me;
79		};
80		/* }}} */
81

worker.js

90%

Line	Hits	Source
1		/* vim: set expandtab tabstop=2 shiftwidth=2 foldmethod=marker: */
2
3	2	var Socket = require('net').Socket;
4
5	2	var common = require('./common');
6	2	var listen = common.listen;
7	2	var debug = common.debug;
8	2	var STATUS = common.STATUS;
9	2	var MESSAGE = common.MESSAGE;
10	2	var MAX_HEARTBEAT_INTERVAL = common.MAX_HEARTBEAT_INTERVAL;
11	2	var arrayJoin = Array.prototype.join;
12
13	2	var NOTICE = function (name, message) {
14	1	debug('worker', arrayJoin.call(arguments, ' '));
15		};
16
17		/* {{{ private function _send() */
18		/**
19		* åç¶è¿ç¨åéæ¶æ¯
20		*
21		* @access private
22		* @param {Number} type: see MESSAGE
23		* @param {Object} data
24		*/
25	2	if (!process.hasOwnProperty('send')) {
26	2	var _send = function (type, data) {
27	0	NOTICE('_SEND', JSON.stringify({
28		'type' : type,
29		'data' : data,
30		}));
31		};
32		} else {
33	0	var _send = function (type, data) {
34	0	try {
35	0	process.send({
36		'type' : type,
37		'data' : data,
38		});
39		} catch (e) {
40	0	NOTICE('ERROR', e.stack);
41	0	process.exit(0);
42		}
43		};
44		}
45		/* }}} */
46
47		/* {{{ private function _accept() */
48	2	var _accept = function (handle, port, callback) {
49	6	if (!handle) {
50	1	return;
51		}
52	5	if (!callback) {
53	1	handle.close();
54	1	handle = null;
55	1	return;
56		}
57
58	4	var _me = new Socket({
59		'handle' : handle,
60		});
61
62	4	_me.readable = true;
63	4	_me.writable = true;
64	4	_me.resume();
65	4	_me.on('error', function (error) {
66	0	NOTICE('SOCKET', error.stack);
67		});
68	4	_me.emit('connect');
69	4	callback(_me, port);
70		};
71		/* }}} */
72
73	2	exports.create = function (options) {
74
75	2	var _me = {};
76
77		/* {{{ æ§å¶åæ° */
78
79	2	var _conf = {};
80	2	options = options \|\| {};
81	2	_conf.heartbeat_interval = parseInt(options.heartbeat_interval, 10) \|\| 2000;
82	2	_conf.terminate_timeout = parseInt(options.terminate_timeout, 10) \|\| 1000;
83	2	if (_conf.heartbeat_interval > MAX_HEARTBEAT_INTERVAL) {
84	1	_conf.heartbeat_interval = MAX_HEARTBEAT_INTERVAL;
85		}
86		/* }}} */
87
88		/**
89		* @å¿è·³æ°æ®
90		*/
91	2	var mstat = {
92		'status' : STATUS.PENDING,
93		'scores' : 0,
94		};
95
96		/**
97		* @å¶ä»workeråæ¥çæ¶æ¯å¤çå½æ°
98		*/
99	2	var onmsg = [];
100
101		/**
102		* @workerç´å¬æ¨¡å¼
103		*/
104	2	var _listener = {};
105
106		/* {{{ å¿è·³æ¹æ³ */
107
108	2	var heartbeat = function () {
109	1	mstat.mem = process.memoryUsage();
110	1	_send(MESSAGE.STATUS, mstat);
111		};
112
113		/* }}} */
114
115		/* {{{ ä¿¡å·å¤ç */
116
117	2	process.on('SIGHUB', function () {});
118	2	process.on('SIGTERM', function () {
119	1	mstat.status = STATUS.STOPING;
120	1	for (var idx in _listener) {
121	1	var _fd = _listener[idx];
122	1	_fd.close();
123	1	_fd = null;
124		}
125	1	_listener = {};
126
127	1	setTimeout(function () {
128	0	process.exit(0);
129		}, _conf.terminate_timeout);
130		});
131	2	process.on('exit', function () {
132	0	NOTICE('terminated after ' + Number(process.uptime()).toFixed(3) + ' seconds.');
133		});
134
135		/* }}} */
136
137		/* {{{ public function ready() */
138		/**
139		* workerè¿å¥è¿è¡ç¶æ
140		*/
141	2	_me.ready = function (callback) {
142	1	mstat = {
143		'status' : STATUS.RUNNING,
144		'scores' : 0,
145		};
146	1	heartbeat();
147	1	setInterval(heartbeat, _conf.heartbeat_interval);
148
149	1	process.on('message', function (msg, handle) {
150	9	if (!msg \|\| !msg.type) {
151	3	return;
152		}
153
154	6	switch (msg.type) {
155		case MESSAGE.WAKEUP:
156	1	if (STATUS.RUNNING === mstat.status) {
157	1	_send(MESSAGE.GET_FD);
158		}
159	1	break;
160
161		case MESSAGE.REQ_FD:
162	2	mstat.scores++;
163	2	_accept(handle, msg.port, callback);
164	2	if (STATUS.RUNNING === mstat.status && msg.data) {
165	1	process.nextTick(function () {
166	1	_send(MESSAGE.GET_FD);
167		});
168		}
169	2	break;
170
171		case MESSAGE.LISTEN:
172	1	var _addr = msg.data;
173	1	if (_addr && !_listener[_addr]) {
174	1	_listener[_addr] = listen(_addr, function (handle, port) {
175	1	mstat.scores++;
176	1	_accept(handle, port, callback);
177		});
178	1	NOTICE('direct listen at "' + _addr + '"');
179		}
180	1	break;
181
182		case MESSAGE.COMMAND:
183	1	onmsg.forEach(function (cb) {
184	1	if (cb && msg.data) {
185	1	cb(msg.data, msg.from, msg.pid);
186		}
187		});
188	1	break;
189
190		default:
191	1	break;
192		}
193		});
194
195	1	return _me;
196		};
197		/* }}} */
198
199		/* {{{ public function onmessage() */
200		/**
201		* æ¶æ¯å¤çå½æ°
202		*
203		* @access public
204		*/
205	2	_me.onmessage = function (cb) {
206	2	if (!cb) {
207	1	onmsg = [];
208		} else {
209	1	onmsg.push(cb);
210		}
211		};
212		/* }}} */
213
214		/* {{{ public function sendto() */
215		/**
216		* åå¶ä»è¿ç¨åéæ¶æ¯
217		*
218		* @access public
219		* @param {String} who, process name
220		* @param {Object} data
221		*/
222	2	_me.sendto = function (who, data) {
223	1	_send(MESSAGE.SENDTO, {
224		'name' : who,
225		'data' : data,
226		});
227		};
228		/* }}} */
229
230		/* {{{ public function reload() */
231		/**
232		* reloadå¶ä»è¿ç¨
233		*
234		* @access public
235		* @param {String} who, process name
236		*/
237	2	_me.reload = function (who) {
238	1	_send(MESSAGE.RELOAD, {
239		'name' : who,
240		});
241		};
242		/* }}} */
243
244	2	return _me;
245
246		};