Merge pull request #12 from wmantly/new

New

lxc.js

@@ -1,5 +1,28 @@
 'use strict';
 var exec = require('child_process').exec;
+var extend = require('node.extend');
+
+
+var parseArgs = function(config){
+	var all = Object.keys(config.defaults);
+	// console.log(all)
+	for(var i=config.required.length; i--;){
+		if(all.indexOf(config.required[i]) !== -1){
+			config.required.splice(i, 1);
+		}
+	}
+
+	if(config.required.length !== 0) return false;
+
+	var out = '';
+	for(var i=0; i< config.takes.length; i++){
+		if(all.indexOf(config.takes[i]) !== -1){
+			out += '--'+config.takes[i]+' '+config.defaults[config.takes[i]]+' ';
+		}
+	}
+
+	return out;
+};
 
 function sysExec(command, callback){
 	command = 'unset XDG_SESSION_ID XDG_RUNTIME_DIR; cgm movepid all virt $$; ' + command;
@@ -13,53 +36,45 @@ function sysExec(command, callback){
 	})(callback));
 };
 
+
 var Container = function(config){
 	this.name = config.name;
-	this.state = config.state;
+	this.state = config.state || 'STOPPED';
-	this.ip = config.ip || (config.ipv4 || '').replace('-', '') || null ;
+	this.ip = config.ip || (config.ipv4 || '').replace('-', '') || null;
+	this.overlayfs = undefined; 
 }
 
-Container.prototype.autoShutDown = function(time) {
+Container.prototype.clone = function(callback){
-	time = time || 600000;
+	var overlayfs = this.overlayfs ? ' -B overlayfs -s ' : '';
 	
-	// this.__shutDownTimeout = setTimeout(function(){}, this.autoShutDown):
+	return sysExec('lxc-clone -o '+this.orig+ ' -n '+this.name + overlayfs, callback);
 };
 
-var lxcORM = function(){
+Container.prototype.start = function(callback){
-	var orm = {}
+	var args = parseArgs({
-	lxc.list(function(data){
+		required: ['name'],
-		for(var idx = data.length; idx--;){
+		takes: ['name'],
-			orm[data[idx].name] = new Container(data[idx]);
+		defaults: extend({}, this)
-		}
+		
 	});
 
-	return orm
+	var that = this;
+	callback = function(callback){
+		that.info();
+		return callback;
+	};
+	return sysExec('lxc-start --daemon '+args, callback);
 };
 
-var lxc = {
+Container.prototype.startEphemeral = function(callback){
-	create: function(name, template, config, callback){
+	var args = parseArgs({
-		return sysExec('lxc-create -n '+name+' -t '+template, callback);
+		required: ['orig'],
-	},
+		takes: ['orig', 'name', 'key', 'union-type', 'keep-data'],
+		defaults: extend({}, this)
 		
-	clone: function(name, base_name, callback){
-		return sysExec('lxc-clone -o '+base_name+ ' -n '+name +' -B overlayfs -s', callback);
-	},
-
-	destroy: function(name, callback){
-		return sysExec('lxc-destroy -n '+ name, function(data){
-			var info = data.match(/Destroyed container/);
-			console.log('destroy info:', info);
-			var args = [true].concat(Array.prototype.slice.call(arguments, 1));
-			return callback.apply(this, args);
 	});
-	},
 
-	start: function(name, callback){
+	var command = 'lxc-start-ephemeral --daemon '+args;
-		return sysExec('lxc-start --name '+name+' --daemon', callback);
-	},
-
-	startEphemeral: function(name, base_name, callback){
-		var command = 'lxc-start-ephemeral -o '+base_name+ ' -n '+name +' --union-type overlayfs -d';
 	return sysExec(command, function(data){
 		console.log('startEphemeral', arguments);
 		if(data.match("doesn't exist.")){
@@ -74,23 +89,82 @@ var lxc = {
 
 		callback({'?': '?', data: data, name: name, base_name: base_name});
 	});
-	},
+};
 
-	stop: function(name, callback){
+Container.prototype.destroy = function(callback){
-		return sysExec('lxc-stop -n '+ name, callback);
+	var args = parseArgs({
-	},
+		required: ['name'],
+		takes: ['name', 'force'],
+		defaults: extend({}, this)
+	});
 
-	freeze: function(name, callback){
+	return sysExec('lxc-destroy '+ args, function(data){
+		var info = data.match(/Destroyed container/);
+		console.log('destroy info:', info);
+		var args = [true].concat(Array.prototype.slice.call(arguments, 1));
+		return callback.apply(this, args);
+	});
+},
+
+Container.prototype.stop = function(callback){
+	var args = parseArgs({
+		required: ['name'],
+		takes: ['name', 'reboot', 'nowait', 'timeout', 'kill'],
+		defaults: extend({}, this)
+		
+	});
+	var that = this;
+	callback = function(callback){
+		that.info();
+		return callback;
+	};
+	return sysExec('lxc-stop '+args, callback);
+};
+
+Container.prototype.freeze = function(callback){
+	var args = parseArgs({
+		required: ['name'],
+		takes: ['name', 'force'],
+		defaults: extend({}, this)
+	});
 	return sysExec('lxc-freeze -n '+name, callback);
-	},
+};
 
-	unfreeze: function(name, callback){
+Container.prototype.unfreeze = function(callback){
-		return sysExec('lxc-unfreeze -n '+name, callback);
-	},
 
-	info: function(name, callback){
+	return sysExec('lxc-unfreeze --name '+this.name, callback);
-		return sysExec('lxc-info -n '+name, function(data){
+};
-			console.log('info', arguments);
+
+Container.prototype.info = function(callback){
+	var args = parseArgs({
+		required: ['name'],
+		takes: ['name', 'reboot', 'nowait', 'timeout', 'kill'],
+		defaults: extend({}, this)
+		
+	});
+	return sysExec('lxc-stop '+args, callback);
+};
+
+Container.prototype.freeze = function(callback){
+	var args = parseArgs({
+		required: ['name'],
+		takes: ['name', 'force'],
+		defaults: extend({}, this)
+	});
+	return sysExec('lxc-freeze -n '+name, callback);
+};
+
+Container.prototype.unfreeze = function(callback){
+
+	return sysExec('lxc-unfreeze --name '+this.name, callback);
+};
+
+Container.prototype.info = function(callback){
+	var that = this;
+	callback = callback || function(){}
+
+	return sysExec('lxc-info --name '+this.name, function(data){
+		// console.log('info', arguments);
 		if(data.match("doesn't exist")){
 			return callback({state: 'NULL'});
 		}
@@ -101,12 +175,74 @@ var lxc = {
 			var temp = data[i].split(/\:\s+/);
 			info[temp[0].toLowerCase().trim()] = temp[1].trim();
 		}
-			var args = [info].concat(Array.prototype.slice.call(arguments, 1));
-			callback.apply(this, args);
-		});
-	},
 
-	list: function(callback){
+		that.updateFromInfo(info);
+
+		var args = [info].concat(Array.prototype.slice.call(arguments, 1));
+		return callback.apply(that, args);
+	});
+};
+
+Container.prototype.updateFromInfo = function(data){
+	var keys = ['state', 'ip', 'total', 'rx', 'tx', 'link', 'kmem', 'memory', 'blkio', 'cpu', 'pid'];
+	for(var i=keys.length; i--;){
+		this[keys[i]] = data[keys[i]];
+	}
+
+	return this;
+}
+
+
+
+
+
+var lxcORM = function(){
+	this.containers = {};
+	this.isReady = false;
+	this.whenReady = [];
+	var that = this;
+
+	this.list(function(data){
+		for(var idx = data.length; idx--;){
+			that.containers[data[idx].name] = new Container(data[idx]);
+			if(idx===0){
+				// console.log('call ready!')
+				that.callReady();
+			}
+		}
+	});
+
+};
+
+lxcORM.prototype.callReady = function(){
+	for(var idx=0; idx<this.whenReady.length; idx--){
+		this.whenReady[idx].apply(this);
+	}
+	this.isReady = true;
+};
+
+lxcORM.prototype.ready = function(callback){
+	if(this.isReady){
+		return callback.apply(this);
+	}
+	else{
+		this.whenReady.push(callback);
+	}
+};
+
+lxcORM.prototype.create = function(args, callback){
+
+	var args = parseArgs({
+		required: ['name', 'template'],
+		takes: ['name', 'template', ' ', 'd', 'r', 'a'],
+		defaults: extend({template:'download', ' ': ' ', d: 'ubuntu', r: 'trusty', a: 'amd64'}, args)
+		
+	})
+
+	return sysExec('lxc-create '+args, callback);
+};
+
+lxcORM.prototype.list = function(callback){
 	sysExec('lxc-ls --fancy', function(data){
 		var output = data.split("\n");
 		var keys = output.splice(0,1)[0].split(/\s+/).slice(0,-1);
@@ -129,10 +265,8 @@ var lxc = {
 		var args = [info].concat(Array.prototype.slice.call(arguments, 1));
 		callback.apply(this, args);
 	});
-	}
 };
 
-module.exports = lxc;
 
-var orm = lxcORM()
+
-setTimeout(function(){console.log(orm)}, 5000)
+module.exports = new lxcORM();