├── README.md
├── .gitignore
├── demo.js
├── package.json
└── SSDB.js


/README.md:
--------------------------------------------------------------------------------
1 | nodessdb
2 | ========
3 | 
4 | SSDB nodejs client
5 | 


--------------------------------------------------------------------------------
/.gitignore:
--------------------------------------------------------------------------------
1 | *.o
2 | *.a
3 | *.class
4 | .DS_Store
5 | *.pyc
6 | *.swp
7 | *_cpy_*
8 | 
9 | 


--------------------------------------------------------------------------------
/demo.js:
--------------------------------------------------------------------------------
 1 | var SSDB = require('./SSDB.js');
 2 | var ssdb = SSDB.connect(host, port);
 3 | 
 4 | ssdb.set('a', new Date(), function(){
 5 | 	console.log('set a');
 6 | });
 7 | ssdb.get('a', function(err, val){
 8 | 	console.log('get a = ' + val);
 9 | 	ssdb.close();
10 | });
11 | 
12 | 
13 | 


--------------------------------------------------------------------------------
/package.json:
--------------------------------------------------------------------------------
 1 | {
 2 |   "name": "nodessdb",
 3 |   "version": "1.0.0",
 4 |   "description": "SSDB nodejs Client",
 5 |   "main": "SSDB.js",
 6 |   "scripts": {
 7 |     "test": "echo \"Error: no test specified\" && exit 1"
 8 |   },
 9 |   "repository": {
10 |     "type": "git",
11 |     "url": "git+https://github.com/ssdb/nodessdb.git"
12 |   },
13 |   "keywords": [
14 |     "foo",
15 |     "bar"
16 |   ],
17 |   "author": "ideawu",
18 |   "license": "MIT",
19 |   "bugs": {
20 |     "url": "https://github.com/ssdb/nodessdb/issues"
21 |   },
22 |   "homepage": "https://github.com/ssdb/nodessdb#readme"
23 | }
24 | 


--------------------------------------------------------------------------------
/SSDB.js:
--------------------------------------------------------------------------------
  1 | /**
  2 |  * Copyright (c) 2013, ideawu
  3 |  * All rights reserved.
  4 |  * @author: ideawu
  5 |  * @link: http://www.ideawu.com/
  6 |  *
  7 |  * SSDB nodejs client SDK.
  8 |  */
  9 | 
 10 | var net = require('net');
 11 | 
 12 | // timeout: microseconds, if ommitted, it will be treated as listener
 13 | // callback(err, ssdb)
 14 | exports.connect = function(host, port, timeout, listener){
 15 | 	var self = this;
 16 | 	var recv_buf = new Buffer(0);
 17 | 	var callbacks = [];
 18 | 	var connected = false;
 19 | 
 20 | 	if(typeof(timeout) == 'function'){
 21 | 		listener = timeout;
 22 | 		timeout = 0;
 23 | 	}
 24 | 	timeout = timeout || 0;
 25 | 	listener = listener || function(){};
 26 | 
 27 | 	var sock = new net.Socket();
 28 | 	sock.on('error', function(e){
 29 | 		if(!connected){
 30 | 			listener('connect_failed', e);
 31 | 		}else{
 32 | 			var callback = callbacks.shift();
 33 | 			callback(['error']);
 34 | 		}
 35 | 	});
 36 | 	sock.connect(port, host, function(){
 37 | 		connected = true;
 38 | 		sock.setNoDelay(true);
 39 | 		sock.setKeepAlive(true);
 40 | 		sock.setTimeout(timeout);
 41 | 		listener(0, self);
 42 | 	});
 43 | 
 44 | 	self.close = function(){
 45 | 		sock.end();
 46 | 	}
 47 | 
 48 | 	self.request = function(cmd, params, callback){
 49 | 		callbacks.push(callback || function(){});
 50 | 		var arr = [cmd].concat(params);
 51 | 		self.send_request(arr);
 52 | 	}
 53 | 
 54 | 	function build_buffer(arr){
 55 | 		var bs = [];
 56 | 		var size = 0;
 57 | 		for(var i = 0; i < arr.length; i++){
 58 | 			var arg = arr[i];
 59 | 			if(arg instanceof Buffer){
 60 | 				//
 61 | 			}else{
 62 | 				arg = new Buffer(arg.toString());
 63 | 			}
 64 | 			bs.push(arg);
 65 | 			size += arg.length;
 66 | 		}
 67 | 		var ret = new Buffer(size);
 68 | 		var offset = 0;
 69 | 		for(var i=0; i<bs.length; i++){
 70 | 			bs[i].copy(ret, offset);
 71 | 			offset += bs[i].length;
 72 | 		}
 73 | 		return ret;
 74 | 	}
 75 | 
 76 | 	self.send_request = function(params){
 77 | 		var bs = [];
 78 | 		for(var i=0;i<params.length;i++){
 79 | 			var p = params[i];
 80 | 			var len = 0;
 81 | 			if(!(p instanceof Buffer)){
 82 | 				p = p.toString();
 83 | 				bs.push(Buffer.byteLength(p));
 84 | 			}else{
 85 | 				bs.push(p.length);
 86 | 			}
 87 | 			bs.push('\n');
 88 | 			bs.push(p);
 89 | 			bs.push('\n');
 90 | 		}
 91 | 		bs.push('\n');
 92 | 		var req = build_buffer(bs);
 93 | 		sock.write(req);
 94 | 		//console.log('write ' + req.length + ' bytes');
 95 | 		//console.log('write: ' + req);
 96 | 	}
 97 | 
 98 | 	sock.on('data', function(data){
 99 | 		recv_buf = build_buffer([recv_buf, data]);
100 | 		while(recv_buf.length > 0){
101 | 			var resp = parse();
102 | 			if(!resp){
103 | 				break;
104 | 			}
105 | 			resp[0] = resp[0].toString();
106 | 			var callback = callbacks.shift();
107 | 			callback(resp);
108 | 		}
109 | 	});
110 | 
111 | 	function memchr(buf, ch, start){
112 | 		start = start || 0;
113 | 		ch = typeof(ch) == 'string'? ch.charCodeAt(0) : ch;
114 | 		for(var i=start; i<buf.length; i++){
115 | 			if(buf[i] == ch){
116 | 				return i;
117 | 			}
118 | 		}
119 | 		return -1;
120 | 	}
121 | 
122 | 	function parse(){
123 | 		var ret = [];
124 | 		var spos = 0;
125 | 		var pos;
126 | 		//console.log('parse: ' + recv_buf.length + ' bytes');
127 | 		while(true){
128 | 			//pos = recv_buf.indexOf('\n', spos);
129 | 			pos = memchr(recv_buf, '\n', spos);
130 | 			if(pos == -1){
131 | 				// not finished
132 | 				return null;
133 | 			}
134 | 			var line = recv_buf.slice(spos, pos).toString();
135 | 			spos = pos + 1;
136 | 			line = line.replace(/^\s+(.*)\s+$/, '\1');
137 | 			if(line.length == 0){
138 | 				// parse end
139 | 				//recv_buf = recv_buf.substr(spos);
140 | 				recv_buf = recv_buf.slice(spos);
141 | 				break;
142 | 			}
143 | 			var len = parseInt(line);
144 | 			if(isNaN(len)){
145 | 				// error
146 | 				console.log('error 1');
147 | 				return null;
148 | 			}
149 | 			if(spos + len > recv_buf.length){
150 | 				// not finished
151 | 				//console.log(spos + len, recv_buf.length);
152 | 				//console.log('not finish');
153 | 				return null;
154 | 			}
155 | 			//var data = recv_buf.substr(spos, len);
156 | 			var data = recv_buf.slice(spos, spos + len);
157 | 			spos += len;
158 | 			ret.push(data);
159 | 
160 | 			//pos = recv_buf.indexOf('\n', spos);
161 | 			pos = memchr(recv_buf, '\n', spos);
162 | 			if(pos == -1){
163 | 				// not finished
164 | 				console.log('error 3');
165 | 				return null;
166 | 			}
167 | 			// '\n', or '\r\n'
168 | 			//if(recv_buf.charAt(spos) != '\n' && recv_buf.charAt(spos) != '\r' && recv_buf.charAt(spos+1) != '\n'){
169 | 			var cr = '\r'.charCodeAt(0);
170 | 			var lf = '\n'.charCodeAt(0);
171 | 			if(recv_buf[spos] != lf && recv_buf[spos] != cr && recv_buf[spos+1] != lf){
172 | 				// error
173 | 				console.log('error 4 ' + recv_buf[spos]);
174 | 				return null;
175 | 			}
176 | 			spos = pos + 1;
177 | 		}
178 | 		return ret;
179 | 	}
180 | 
181 | 	// callback(err, val);
182 | 	// err: 0 on sucess, or error_code(string) on error
183 | 	self.get = function(key, callback){
184 | 		self.request('get', [key], function(resp){
185 | 			if(callback){
186 | 				var err = resp[0] == 'ok'? 0 : resp[0];
187 | 				var val = resp[1];
188 | 				callback(err, val);
189 | 			}
190 | 		});
191 | 	}
192 | 
193 | 	// callback(err);
194 | 	self.set = function(key, val, callback){
195 | 		self.request('set', [key, val], function(resp){
196 | 			if(callback){
197 | 				var err = resp[0] == 'ok'? 0 : resp[0];
198 | 				callback(err);
199 | 			}
200 | 		});
201 | 	}
202 | 
203 | 	// callback(err);
204 |     self.setx = function(key, val, ttl, callback){
205 |         self.request('setx', [key, val, ttl], function(resp){
206 |             if(callback){
207 |                 var err = resp[0] == 'ok'? 0 : resp[0];
208 |                 callback(err, resp[1].toString());
209 |             }
210 |         });
211 |     }
212 | 
213 |     // callback(err);
214 |     self.ttl = function(key, callback){
215 |         self.request('ttl', [key], function(resp){
216 |             if(callback){
217 |                 var err = resp[0] == 'ok'? 0 : resp[0];
218 |                 callback(err,resp[1].toString());
219 |             }
220 |         });
221 |     }
222 | 
223 | 	// callback(err);
224 | 	self.del = function(key, callback){
225 | 		self.request('del', [key], function(resp){
226 | 			if(callback){
227 | 				var err = resp[0] == 'ok'? 0 : resp[0];
228 | 				callback(err);
229 | 			}
230 | 		});
231 | 	}
232 | 
233 | 	// callback(err, {index:[], items:{key:score}})
234 | 	self.scan = function(key_start, key_end, limit, callback){
235 | 		self.request('scan', [key_start, key_end, limit], function(resp){
236 | 			if(callback){
237 | 				var err = resp[0] == 'ok'? 0 : resp[0];
238 | 				if(resp.length % 2 != 1){
239 | 					callback('error');
240 | 				}else{
241 | 					var data = {index: [], items: {}};
242 | 					for(var i=1; i<resp.length; i+=2){
243 | 						var k = resp[i].toString();
244 | 						var v = resp[i+1].toString();
245 | 						data.index.push(k);
246 | 						data.items[k] = v;
247 | 					}
248 | 					callback(err, data);
249 | 				}
250 | 			}
251 | 		});
252 | 	}
253 | 
254 | 	// callback(err, [])
255 | 	self.keys = function(key_start, key_end, limit, callback){
256 | 		self.request('keys', [key_start, key_end, limit], function(resp){
257 | 			if(callback){
258 | 				var err = resp[0] == 'ok'? 0 : resp[0];
259 | 				var data = [];
260 | 				for(var i=1; i<resp.length; i++){
261 | 					var k = resp[i].toString();
262 | 					data.push(k);
263 | 				}
264 | 				callback(err, data);
265 | 			}
266 | 		});
267 | 	}
268 | 
269 | 	//////////////////////////////////////////////
270 | 
271 | 	// callback(score)
272 | 	self.zget = function(name, key, callback){
273 | 		self.request('zget', [name, key], function(resp){
274 | 			if(callback){
275 | 				var err = resp[0] == 'ok'? 0 : resp[0];
276 | 				if(resp.length == 2){
277 | 					var score = parseInt(resp[1]);
278 | 					callback(err, score);
279 | 				}else{
280 | 					var score = 0;
281 | 					callback('error');
282 | 				}
283 | 			}
284 | 		});
285 | 	}
286 | 
287 | 	// callback(size)
288 | 	self.zsize = function(name, callback){
289 | 		self.request('zsize', [name], function(resp){
290 | 			if(callback){
291 | 				var err = resp[0] == 'ok'? 0 : resp[0];
292 | 				if(resp.length == 2){
293 | 					var size = parseInt(resp[1]);
294 | 					callback(err, size);
295 | 				}else{
296 | 					var score = 0;
297 | 					callback('error');
298 | 				}
299 | 			}
300 | 		});
301 | 	}
302 | 
303 | 	// callback(err);
304 | 	self.zset = function(name, key, score, callback){
305 | 		self.request('zset', [name, key, score], function(resp){
306 | 			if(callback){
307 | 				var err = resp[0] == 'ok'? 0 : resp[0];
308 | 				callback(err);
309 | 			}
310 | 		});
311 | 	}
312 | 
313 | 	// callback(err);
314 | 	self.zdel = function(name, key, callback){
315 | 		self.request('zdel', [name, key], function(resp){
316 | 			if(callback){
317 | 				var err = resp[0] == 'ok'? 0 : resp[0];
318 | 				callback(err);
319 | 			}
320 | 		});
321 | 	}
322 | 
323 | 	// callback(err, {index:[], items:{key:score}})
324 | 	self.zscan = function(name, key_start, score_start, score_end, limit, callback){
325 | 		self.request('zscan', [name, key_start, score_start, score_end, limit], function(resp){
326 | 			if(callback){
327 | 				var err = resp[0] == 'ok'? 0 : resp[0];
328 | 				if(resp.length % 2 != 1){
329 | 					callback('error');
330 | 				}else{
331 | 					var data = {index: [], items: {}};
332 | 					for(var i=1; i<resp.length; i+=2){
333 | 						var k = resp[i].toString();
334 | 						var v = parseInt(resp[i+1]);
335 | 						data.index.push(k);
336 | 						data.items[k] = v;
337 | 					}
338 | 					callback(err, data);
339 | 				}
340 | 			}
341 | 		});
342 | 	}
343 | 
344 | 	// callback(err, [])
345 | 	self.zlist = function(name_start, name_end, limit, callback){
346 | 		self.request('zlist', [name_start, name_end, limit], function(resp){
347 | 			if(callback){
348 | 				var err = resp[0] == 'ok'? 0 : resp[0];
349 | 				var data = [];
350 | 				for(var i=1; i<resp.length; i++){
351 | 					var k = resp[i].toString();
352 | 					data.push(k);
353 | 				}
354 | 				callback(err, data);
355 | 			}
356 | 		});
357 | 	}
358 | 	
359 | 	// callback(err,sum)
360 | 	self.zsum = function(name, score_start, score_end, callback){
361 | 		self.request('zsum', [name,score_start,score_end], function(resp){
362 | 			if(callback){
363 | 				var err = resp[0] == 'ok'? 0 : resp[0];
364 | 				if(resp.length == 2){
365 | 					var size = parseInt(resp[1]);
366 | 					callback(err, size);
367 | 				}else{
368 | 					callback('error');
369 | 				}
370 | 			}
371 | 		});
372 | 	}
373 | 
374 | 	//////////////////////////////////////////////
375 | 
376 | 	// callback(val)
377 | 	self.hget = function(name, key, callback){
378 | 		self.request('hget', [name, key], function(resp){
379 | 			if(callback){
380 | 				var err = resp[0] == 'ok'? 0 : resp[0];
381 | 				if(resp.length == 2){
382 | 					callback(err, resp[1]);
383 | 				}else{
384 | 					callback('error');
385 | 				}
386 | 			}
387 | 		});
388 | 	}
389 | 
390 | 	// callback(err);
391 | 	self.hset = function(name, key, val, callback){
392 | 		self.request('hset', [name, key, val], function(resp){
393 | 			if(callback){
394 | 				var err = resp[0] == 'ok'? 0 : resp[0];
395 | 				callback(err);
396 | 			}
397 | 		});
398 | 	}
399 | 
400 | 	// callback(err);
401 | 	self.hdel = function(name, key, callback){
402 | 		self.request('hdel', [name, key], function(resp){
403 | 			if(callback){
404 | 				var err = resp[0] == 'ok'? 0 : resp[0];
405 | 				callback(err);
406 | 			}
407 | 		});
408 | 	}
409 | 
410 | 	// callback(err, {index:[], items:{key:score}})
411 | 	self.hscan = function(name, key_start, key_end, limit, callback){
412 | 		self.request('hscan', [name, key_start, key_end, limit], function(resp){
413 | 			if(callback){
414 | 				var err = resp[0] == 'ok'? 0 : resp[0];
415 | 				if(resp.length % 2 != 1){
416 | 					callback('error');
417 | 				}else{
418 | 					var data = {index: [], items: {}};
419 | 					for(var i=1; i<resp.length; i+=2){
420 | 						var k = resp[i].toString();
421 | 						var v = resp[i+1].toString();
422 | 						data.index.push(k);
423 | 						data.items[k] = v;
424 | 					}
425 | 					callback(err, data);
426 | 				}
427 | 			}
428 | 		});
429 | 	}
430 | 
431 | 	// callback(err, [])
432 | 	self.hlist = function(name_start, name_end, limit, callback){
433 | 		self.request('hlist', [name_start, name_end, limit], function(resp){
434 | 			if(callback){
435 | 				var err = resp[0] == 'ok'? 0 : resp[0];
436 | 				var data = [];
437 | 				for(var i=1; i<resp.length; i++){
438 | 					var k = resp[i].toString();
439 | 					data.push(k);
440 | 				}
441 | 				callback(err, data);
442 | 			}
443 | 		});
444 | 	}
445 | 
446 | 	// callback(size)
447 | 	self.hsize = function(name, callback){
448 | 		self.request('hsize', [name], function(resp){
449 | 			if(callback){
450 | 				var err = resp[0] == 'ok'? 0 : resp[0];
451 | 				if(resp.length == 2){
452 | 					var size = parseInt(resp[1]);
453 | 					callback(err, size);
454 | 				}else{
455 | 					var score = 0;
456 | 					callback('error');
457 | 				}
458 | 			}
459 | 		});
460 | 	}
461 | 
462 | 	return self;
463 | }
464 | 
465 | 
466 | /*
467 | example:
468 | var SSDB = require('./SSDB.js');
469 | var ssdb = SSDB.connect(host, port, function(err){
470 | 	if(err){
471 | 		return;
472 | 	}
473 | 	ssdb.set('a', new Date(), function(){
474 | 		console.log('set a');
475 | 	});
476 | });
477 | */
478 | 
479 | 


--------------------------------------------------------------------------------