json-db.js

/* $Id: json-db.js,v 1.40 2015/11/04 09:43:45 deuce Exp $ */

/*     
	JSON database  - for Synchronet 3.15a+ (2011)

	-	code by mcmlxxix
	-	model concept by deuce
	-	dongs by echicken
	-	positive reinforcement by cyan
	-	function names by weatherman
	-	mild concern by digitalman 

	methods:
	
	-	Database.status(client,location);
	-	Database.who(client,location); 
	-	Database.query(client,query);
	-	Database.cycle(Date.now());
	-	Database.load();
	-	Database.save(Date.now());
	-	Database.lock(client,record,property,lock_type);
	-	Database.read(client,record,property);
	-	Database.pop(client,record,property);
	-	Database.shift(client,record,property);
	-	Database.write(client,record,property,data);
	-	Database.push(client,record,property,data);
	-	Database.unshift(client,record,property,data);
	-	Database.remove(client,record,property);
	-	Database.subscribe(client,record,property);
	-	Database.unsubscribe(client,record,property);
	
	optional arguments:
	
	-	argv[0] = filename;
	
*/

function JSONdb (fileName, scope) {
	this.VERSION = "$Revision: 1.40 $".replace(/\$/g,'').split(' ')[1];
	
    /* database storage file */
	if(fileName) 
		this.file=new File(fileName);
    else 
		this.file=undefined;
	
    /* master database object */
	this.masterData={
		/* top-level data object */
		data:{}
	};

    /* master shadow object */
	this.masterShadow={
		/* top-level data object */
		data:{}
	};
	
	/* queued array of data requests (get/put/create/delete) */
	this.queue={};
	
	/* general list of db subscribers (for quick release if no subscriptions) */
	this.subscriptions={};
	
	/* list of disconnected clients */
	this.disconnected={};
	
	/* database settings */
	this.settings={
		/* misc settings */
		FILE:system.ctrl_dir + "json-db.ini",
		FILE_BUFFER:524288,
		LAST_SAVE:-1,
		SAVE_INTERVAL:-1,
		KEEP_READABLE:false,
		READ_ONLY:false,
		UPDATES:false,
		DEFAULT_TIMEOUT:0
	};
	
	/* lock constants */
	var locks = {
		UNLOCK:-1,
		NONE:undefined,
		READ:1,
		WRITE:2,
	}
	
	/* operation constants */
	var opers = {
		READ:0,
		WRITE:1,
		LOCK:2,
		PUSH:3,
		POP:4,
		SHIFT:5,
		UNSHIFT:6,
		DELETE:7,
		SUBSCRIBE:8,
		UNSUBSCRIBE:9,
		WHO:10,
		STATUS:11,
		KEYS:12,
		SLICE:13,
		KEYTYPES:14,
		SPLICE:15
	}
	
	/* error constants */
	var errors = {
		INVALID_REQUEST:0,
		OBJECT_NOT_FOUND:1,
		NOT_LOCKED:2,
		LOCKED_WRITE:3,
		LOCKED_READ:4,
		DUPLICATE_LOCK:5,
		DUPLICATE_SUB:6,
		NON_ARRAY:7,
		READ_ONLY:8,
		INVALID_LOCK:9,
		INVALID_OPER:10
	};
	
	/*************************** database methods ****************************/
    /* subscribe a client to an object */
    this.subscribe = function(request,record) {
 		var client = request.client;
		/*  TODO: expire existing subscribers after  certain amount of time, maybe */
		if(!this.subscriptions[client.id]) {
			this.subscriptions[client.id] = {};
		}
		if(!this.subscriptions[client.id][record.location]) {
	        record.shadow[record.property]._subscribers[client.id]=client;
			this.subscriptions[client.id][record.location]=record;
			record.subtime = Date.now();
			send_subscriber_updates(client,record,"SUBSCRIBE");
		}
		else if(this.subscriptions[client.id][record.location]) {
			log(LOG_WARNING,"duplicate subscription: " + client.id + "@" + record.location);
			//this.error(client,errors.DUPLICATE_SUB);
		}
		return true;
    };
    
    /* unsubscribe a client from an object */
    this.unsubscribe = function(request,record) {
		var client = request.client;
		if(this.subscriptions[client.id] && this.subscriptions[client.id][record.location]) {
			delete record.shadow[record.property]._subscribers[client.id];
			delete this.subscriptions[client.id][record.location];
			if(count(this.subscriptions[client.id]) == 0)
				delete this.subscriptions[client.id];
			send_subscriber_updates(client,record,"UNSUBSCRIBE");
		}
		else {
			log(LOG_WARNING,"invalid subscription: " + client.id + "@" + record.location);
			//this.error(client,errors.INVALID_REQUEST);
		}
		return true;
    };
    
    /* The point of a read lock is *only* to prevent someone from
	getting a write lock... just a simple counter is usually enough. */
    this.lock = function(request,record) {
		var client = request.client;
		switch(request.data) {
		/* if the client wants to read... */
		case locks.READ:
			/* if this is a duplicate lock attempt */
			if(record.info.lock[client.id]) {
				this.error(client,errors.DUPLICATE_LOCK);
				return true;
			}
			switch(record.info.lock_type) {
			case locks.READ:
				/* if there are any pending write locks, deny */
				if(record.info.lock_pending) {
					return false;
				}
				/* otherwise, we can read lock */
				else {
					record.shadow[record.property]._lock[client.id] = new Lock(
						request.data,
						Date.now()
					);
					return true;
				}
			/* we cant lock a record that is already locked for reading */
			case locks.WRITE:
				return false;
			/* if the record isnt locked at all, we can lock */
			case locks.NONE:
				record.shadow[record.property]._lock[client.id] = new Lock(
					request.data,
					Date.now()
				);
				return true;
			}
			break;
		/* if the client wants to write... */