Create radisk3.js

lib/radisk3.js

@@ -0,0 +1,157 @@
+;(function(){ // RAD
+console.log("Warning: Experimental rewrite of RAD to use Book. It is not API compatible with RAD yet and is very alpha.");
+var sT = setTimeout, Book = sT.Book, RAD = sT.RAD || (sT.RAD = function(){
+	var r = async function rad(word, is, reply){
+		if(!b){ start(word, is, reply); return r }
+		if(is === undefined || 'function' == typeof is){ // THIS IS A READ:
+			var page = b.page(word);
+			if(page.from){
+				return is(null, page);
+			}
+			read(word, is, page); // get from disk
+			return 
+		}
+		//console.log("OFF");return;
+		// ON WRITE:
+		// batch until read from disk is done (and if a write was going, do that first)
+		b(word, is);
+		write(word, reply);
+		return r;
+	}, b;
+
+
+async function read(word, reply, page){
+	var p = page;//b.page(word);
+	get(p, function(err, disk){
+		if(err){ console.log("ERR!"); return }
+		p.from = disk || p.from;
+		reply && reply(err, p);
+	})
+}
+
+async function write(word, reply){
+	var p = b.page(word), tmp;
+	if(tmp = p.saving){ reply && tmp.push(reply); return } p.saving = [reply];
+	var S = +new Date; console.log("writing", p.substring(), 'since last', S - p.saved, RAD.c, 'records', env.count++, 'mid-swap.');
+	get(p, function(err, disk){
+		if(err){ console.log("ERR!"); return }
+		console.log("MERGE:", p.substring(), disk);
+		p.from = disk || p.from; // TODO: NEED TO MERGE! AND HANDLE ERR!
+		//p.list = p.text = p.from = 0;
+		//p.first = p.first.word || p.first;
+		tmp = p.saving; p.saving = [];
+		put(p, ''+p, function(err, ok){
+			env.count--; p.saved = +new Date; //console.log("wrote", p.substring(), (p.saved = +new Date) - S);
+			if(!p.saving.length){ p.saving = 0; return } p.saving = 0;
+			write(word, reply);
+		});
+	})
+}
+function put(file, data, cb){
+	file.first && (file = Book.slot(file.first)[0]);
+	put[file = fname(file)] = {data: data};
+	RAD.put(file, data, function(err, ok){
+		delete put[file];
+		cb && cb(err, ok);
+	});
+};
+function get(file, cb){ var tmp;
+	file.first && (file = Book.slot(file.first)[0]);
+	if(tmp = put[file = fname(file)]){ cb(u, tmp.data); return }
+	if(tmp = get[file]){ tmp.push(cb); return } get[file] = [cb];
+	RAD.get(file, function(err, data){
+		tmp = get[file]; delete get[file];
+		var i = -1, f; while(f = tmp[++i]){ f(err, data) } // CPU SCHEDULE?
+	});
+};
+
+function start(word, is, reply){
+	if(b){ r(word, is, reply); return }
+	get(' ', function(err, d){
+		if(err){ reply && reply(err); return }
+		if(b){ r(word, is, reply); return }
+		//wrap(b = r.book = Book(d));
+		(b = r.book = Book()).list = Book.slot(d);
+		watch(b).list[0] = "'!'";
+		r(word, is, reply);
+	})
+}
+function watch(b){ // SPLIT LOGIC!
+	var split = b.split;
+	b.list.toString = function(){
+		console.time();
+		var i = -1, t = '', p; while(p = this[++i]){
+			t += "|"+p.substring();
+		}
+		t += "|";
+		console.timeEnd();
+		return t;
+	}
+	b.split = function(next, page){
+		console.log("SPLIT!!!!", b.list.length);
+		put(' ', ''+b.list, function(err, ok){
+			if(err){ console.log("ERR!"); return }
+			// ??
+		});
+	}
+	return b;
+}
+
+
+	return r;
+}), MAX = 1000/* 300000000 */;
+
+function ename(t){ return encodeURIComponent(t).replace(/\*/g, '%2A').slice(0,250) }
+function fname(p){ return opt.file+'/'+ename(p.substring()) }
+  
+var opt = {};
+opt.file = String(opt.file || 'radata');
+  
+// junk below that needs to be cleaned up and corrected for the actual correct RAD API.
+var env = {}, nope = function(){}, nah = function(){ return nope }, u;
+env.require = (typeof require !== ''+u && require) || nope;
+env.process = (typeof process != ''+u && process) || {memoryUsage: nah};
+env.os = env.require('os') || {totalmem: nope, freemem: nope};
+env.v8 = env.require('v8') || {getHeapStatistics: nah};
+env.fs = env.require('fs') || {writeFile: nope, readFile: nope};
+
+
+env.max = env.v8.getHeapStatistics().total_available_size / (2**12);
+
+env.count = env.last = 0;
+return;
+
+//if(err && 'ENOENT' === (err.code||'').toUpperCase()){ err = null }
+
+setInterval(function(){
+	var stats = {memory: {}};
+
+	stats.memory.total = env.os.totalmem() / 1024 / 1024; // in MB
+	stats.memory.free = env.os.freemem() / 1024 / 1024; // in MB
+	stats.memory.hused = env.v8.getHeapStatistics().used_heap_size / 1024 / 1024; // in MB
+	stats.memory.used = env.process.memoryUsage().rss / 1024 / 1024; // in MB
+	console.log(stats.memory);
+}, 9);
+
+}());
+
+
+
+
+
+;(function(){ // temporary fs storage plugin, needs to be refactored to use the actual RAD plugin interface.
+var fs;
+try{fs = require('fs')}catch(e){};
+if(!fs){ return }
+
+var sT = setTimeout, RAD = sT.RAD;
+RAD.put = function(file, data, cb){
+	fs.writeFile(file, data, cb);
+}
+RAD.get = function(file, cb){
+	fs.readFile(file, function(err, data){
+		if(err && 'ENOENT' === (err.code||'').toUpperCase()){ return cb() }
+		cb(err, data.toString());
+	});
+}
+}());