+/// # valac --pkg gio-2.0 --pkg gtk+-3.0 --pkg posix Spawn.vala -o /tmp/Spawn
-using Gee; // for array list?
+using GLib;
+using Gtk;
+// compile valac
+
+
+///using Gee; // for array list?
+/*
static int main (string[] args) {
// A reference to our file
- var file = File.new_for_path ("data.txt");
- var m = new Monitor();
+
+ var cfg = new SpawnConfig("", { "ls" } , { "" });
+ cfg.setHandlers(
+ (line) => {
+ stdout.printf("%s\n", line);
+ },
+ null,null,null );
+ cfg.setOptions(
+ false, // async
+ false, // exceptions?? needed??
+ false // debug???
+ );
+ try {
+ new Spawn(cfg);
+
+ } catch (Error e) {
+ stdout.printf("Error %s", e.message);
+ }
+
return 0;
}
-
-var Gio = imports.gi.Gio;
-var GLib = imports.gi.GLib;
+*/
+//var Gio = imports.gi.Gio;
+//var GLib = imports.gi.GLib;
/**
* Library to wrap GLib.spawn_async_with_pipes
*
* usage:
-*
-* Spawn = import.Spawn;
-*
-* simple version..
-* var output = Spawn.run({
-* cwd : '/home',
-* args : [ 'ls', '-l' ],
-* env : [], // optional
-* listeners : {
- output : function (line) { Seed.print(line); },
-* stderr : function (line) {Seed.print("ERROR" + line); },
-* input : function() { return 'xxx' },
-* }
-* });
-*
-*
-*
+* v
*
-*
-*var output = Spawn.run( SpawnConfig() {
+*var output = new Spawn( SpawnConfig() {
cwd = "/home", // empty string to default to homedirectory.
args = {"ls", "-l" },
evn = {},
*
*
*/
-delegate void SpawnOutput(string line);
-delegate void SpawnErr(string line);
-delegate string SpawnInput();
-
-
+public delegate void SpawnOutput(string line);
+public delegate void SpawnErr(string line);
+public delegate string SpawnInput();
+public delegate void SpawnFinish(int result, string output);
+
-struct SpawnConfig
-struct SpawnConfig {
+public class SpawnConfig {
public string cwd;
public string[] args;
public string[] env;
- public boolean async;
- public bookean exceptions; // fire exceptions.
+ public bool async;
+ public bool exceptions; // fire exceptions.
+ public bool debug; // fire exceptions.
- public SpawnOutput output
+ public SpawnOutput output;
public SpawnErr stderr;
public SpawnInput input;
+
// defaults..
- public SpawnConfig() {
- cwd = "";
- args = [];
- env = [];
- async = false;
- exceptions = false;
-
+ public SpawnConfig(string cwd,
+ string[] args,
+ string[] env
+ ) {
+ this.cwd = cwd;
+ this.args = args;
+ this.env = env;
+
+ async = false;
+ exceptions = true;
+ debug = false;
+
+ output = null;
+ stderr = null;
+ input = null;
+
}
+
+
+
+ public void setHandlers(
+ SpawnOutput? output,
+ SpawnErr? stderr,
+ SpawnInput? input
+
+ ) {
+ this.output = output;
+ this.stderr = stderr;
+ this.input = input;
+
+ }
+
+
+}
+
+public errordomain SpawnError {
+ NO_ARGS,
+ WRITE_ERROR,
+ EXECUTE_ERROR
+
}
/**
public class Spawn : Object
{
+ SpawnConfig cfg;
-
- public Spawn(SpawnConfig cfg)
+ public Spawn(SpawnConfig cfg) throws Error
{
this.cfg = cfg;
-
+ this.output = "";
+ this.stderr = "";
- this.cwd = this.cfg.cwd.length || GLib.get_home_dir();
- if (!this.cfg.args.length) {
- throw "No arguments";
- }
+ this.cfg.cwd = this.cfg.cwd.length < 1 ? GLib.Environment.get_home_dir() : this.cfg.cwd;
+ if (this.cfg.args.length < 0) {
+ throw new SpawnError.NO_ARGS("No arguments");
+ }
+ if (!this.cfg.async) {
+ this.run((res, output) => { });
+ }
}
- ctx : false, // the mainloop ctx.
-
- exceptions : false,
- debug : false,
+ MainLoop ctx = null; // the mainloop ctx.
+
/**
* @property output {String} resulting output
*/
- output : '',
+ public string output;
/**
* @property stderr {String} resulting output from stderr
*/
- stderr : '',
+ public string stderr;
/**
* @property result {Number} execution result.
*/
- result: 0,
+ int result= 0;
/**
* @property pid {Number} pid of child process (of false if it's not running)
*/
- pid : false,
+ int pid = -1;
/**
* @property in_ch {GLib.IOChannel} input io channel
*/
- in_ch : false,
+ IOChannel in_ch = null;
/**
* @property out_ch {GLib.IOChannel} output io channel
*/
- out_ch : false,
+ IOChannel out_ch = null;
/**
* @property err_ch {GLib.IOChannel} stderr io channel
*/
- err_ch : false,
+ IOChannel err_ch = null;
+ /**
+ * @property err_src {int} the watch for errors
+ */
+
+ int err_src = -1;
+ /**
+ * @property err_src {int} the watch for output
+ */
+ int out_src = -1;
+
+
+ unowned SpawnFinish on_finished;
+
/**
*
* @method run
* Run the configured command.
- * result is applied to object properties (eg. 'output' or 'stderr')
+ * result is applied to object properties (eg. '?' or 'stderr')
* @returns {Object} self.
*/
- run : function()
+ public void run( SpawnFinish finished_cb) throws SpawnError, GLib.SpawnError, GLib.IOChannelError
{
- var _this = this;
-
- var err_src = false;
- var out_src = false;
- var ret = {};
+ this.on_finished = finished_cb;
+ err_src = -1;
+ out_src = -1;
+ int standard_input;
+ int standard_output;
+ int standard_error;
+
+
- if (this.debug) {
- print("cd " + this.cwd +";" + this.args.join(" "));
+ if (this.cfg.debug) {
+ GLib.debug("cd %s; %s\n" , this.cfg.cwd , string.joinv(" ", this.cfg.args));
}
- var gret = GLib.spawn_async_with_pipes(this.cwd, this.args, this.env,
- GLib.SpawnFlags.DO_NOT_REAP_CHILD + GLib.SpawnFlags.SEARCH_PATH ,
- null, null, ret);
-
- var isSeed = true;
- if (typeof(Seed) == 'undefined') {
- ret = {
- child_pid : gret[1],
- standard_input : gret[2],
- standard_output: gret[3],
- standard_error: gret[4]
- };
- isSeed = false;
+ // stdout:
+ if (!this.cfg.async) {
+ string ls_stdout;
+ string ls_stderr;
+ int ls_status;
+
+ Process.spawn_sync (
+ this.cfg.cwd,
+ this.cfg.args,
+ this.cfg.env,
+ SpawnFlags.SEARCH_PATH,
+ null,
+ out ls_stdout,
+ out ls_stderr,
+ out ls_status
+ );
+ this.output = ls_stdout;
+ this.stderr = ls_stderr;
+ this.result = ls_status;
+ if (this.cfg.exceptions && this.result != 0) {
+ var errstr = string.joinv(" ", this.cfg.args) + "\n";
+ errstr += this.output;
+ errstr += this.output.length > 0 ? "\n" : "";
+ errstr += this.stderr;
+ //print("Throwing execute error:%s\n", errstr);
+ throw new SpawnError.EXECUTE_ERROR(errstr);
+ //this.toString = function() { return this.stderr; };
+ ///throw new Exception this; // we throw self...
+ }
+ return;
+
}
- //print(JSON.stringify(gret));
- this.pid = ret.child_pid;
-
- if (this.debug) {
- print("PID: " + this.pid);
- }
-
+
+
+ Process.spawn_async_with_pipes (
+ this.cfg.cwd,
+ this.cfg.args,
+ this.cfg.env,
+ SpawnFlags.SEARCH_PATH | SpawnFlags.DO_NOT_REAP_CHILD,
+ null,
+ out this.pid,
+ out standard_input,
+ out standard_output,
+ out standard_error);
+
- GLib.child_watch_add(GLib.PRIORITY_DEFAULT, this.pid, function(pid, result) {
- _this.result = result;
- if (_this.debug) {
- print("child_watch_add : result: " + result);
- }
- _this.read(_this.out_ch);
- _this.read(_this.err_ch);
-
-
- GLib.spawn_close_pid(_this.pid);
- _this.pid = false;
- if (_this.ctx) {
- _this.ctx.quit();
- }
- tidyup();
- //print("DONE TIDYUP");
- if (_this.listeners.finish) {
- _this.listeners.finish.call(this, _this.result);
- }
- });
-
- function tidyup()
- {
- if (_this.pid) {
- GLib.spawn_close_pid(_this.pid); // hopefully kills it..
- _this.pid = false;
- }
- if (_this.in_ch) _this.in_ch.close();
- if (_this.out_ch) _this.out_ch.close();
- if (_this.err_ch) _this.err_ch.close();
- // blank out channels
- _this.in_ch = false;
- _this.err_ch = false;
- _this.out_ch = false;
- // rmeove listeners !! important otherwise we kill the CPU
- if (err_src !== false) GLib.source_remove(err_src);
- if (out_src !== false) GLib.source_remove(out_src);
- err_src = false;
- out_src = false;
+
+
+ //print(JSON.stringify(gret));
+
+ if (this.cfg.debug) {
+ GLib.debug("PID: %d\n" ,this.pid);
}
+ this.ref(); // additional ref - cleared on tidyup...
- this.in_ch = new GLib.IOChannel.unix_new(ret.standard_input);
- this.out_ch = new GLib.IOChannel.unix_new(ret.standard_output);
- this.err_ch = new GLib.IOChannel.unix_new(ret.standard_error);
+ this.in_ch = new GLib.IOChannel.unix_new(standard_input);
+ this.out_ch = new GLib.IOChannel.unix_new(standard_output);
+ this.err_ch = new GLib.IOChannel.unix_new(standard_error);
// make everything non-blocking!
+
+ // using NONBLOCKING only works if io_add_watch
+ //returns true/false in right conditions
+ this.in_ch.set_flags (GLib.IOFlags.NONBLOCK);
+ this.out_ch.set_flags (GLib.IOFlags.NONBLOCK);
+ this.err_ch.set_flags (GLib.IOFlags.NONBLOCK);
+
- // using NONBLOCKING only works if io_add_watch
- //returns true/false in right conditions
- this.in_ch.set_flags (GLib.IOFlags.NONBLOCK);
- this.out_ch.set_flags (GLib.IOFlags.NONBLOCK);
- this.err_ch.set_flags (GLib.IOFlags.NONBLOCK);
-
-
- // add handlers for output and stderr.
- out_src= GLib.io_add_watch(this.out_ch, GLib.PRIORITY_DEFAULT,
- GLib.IOCondition.OUT + GLib.IOCondition.IN + GLib.IOCondition.PRI + GLib.IOCondition.HUP + GLib.IOCondition.ERR,
- function() {
-
- return _this.read(_this.out_ch);
+
+ ChildWatch.add (this.pid, this.on_child_watch);
+
+
+
+
+
+ // add handlers for output and stderr.
+
+ this.out_src = (int) this.out_ch.add_watch (
+ IOCondition.OUT | IOCondition.IN | IOCondition.PRI | IOCondition.HUP | IOCondition.ERR ,
+ (channel, condition) => {
+ return this.read(channel);
+ //return this.out_ch != null ? this.read(this.out_ch) : true;
}
);
- err_src= GLib.io_add_watch(this.err_ch, GLib.PRIORITY_DEFAULT,
- GLib.IOCondition.ERR + GLib.IOCondition.IN + GLib.IOCondition.PRI + GLib.IOCondition.OUT + GLib.IOCondition.HUP,
- function()
- {
- return _this.read(_this.err_ch);
-
- });
-
-
+ this.err_src = (int) this.err_ch.add_watch (
+ IOCondition.OUT | IOCondition.IN | IOCondition.PRI | IOCondition.HUP | IOCondition.ERR ,
+ (channel, condition) => {
+ return this.read(channel);
+ //return this.err_ch != null ? this.read(this.err_ch) : true;
+ }
+ );
+
// call input..
- if (this.pid !== false) {
- // child can exit before 1we get this far..
- if (this.listeners.input) {
- print("Trying to call listeners");
+ if (this.pid > -1) {
+ // child can exit before we get this far..
+ if (this.cfg.input != null) {
+ if (this.cfg.debug) GLib.debug("Trying to call listeners");
try {
- this.write(this.listeners.input.call(this));
- // this probably needs to be a bit smarter...
- //but... let's close input now..
- this.in_ch.close();
- _this.in_ch = false;
-
-
-
-
-
- } catch (e) {
- tidyup();
- throw e;
+ this.write(this.cfg.input());
+ // this probably needs to be a bit smarter...
+ //but... let's close input now..
+ this.in_ch.shutdown(true);
+ this.in_ch = null;
+
+
+ } catch (Error e) {
+ this.tidyup();
+ return;
+ // throw e;
}
}
+
}
- // async - if running - return..
- if (this.async && this.pid) {
- return this;
+ // async - if running - return..
+ if (this.cfg.async && this.pid > -1) {
+ //this.ref();
+ return;
}
// start mainloop if not async..
- if (this.pid !== false) {
- if (this.debug) {
- print("starting main loop");
- }
-
- this.ctx = isSeed ? new GLib.MainLoop.c_new (null, false) : GLib.MainLoop.new (null, false);;
- this.ctx.run(false); // wait fore exit?
-
+ if (this.pid > -1) {
+ //print("starting main loop");
+ if (this.cfg.debug) {
+ GLib.debug("starting main loop");
+ }
+ this.ctx = new MainLoop ();
+ this.ctx.run(); // wait fore exit?
+ if (this.cfg.debug) {
+ GLib.debug(" main loop done");
+ }
//print("main_loop done!");
} else {
- tidyup(); // tidyup get's called in main loop.
+ this.tidyup(); // tidyup get's called in main loop.
}
- if (this.exceptions && this.result != 0) {
- this.toString = function() { return this.stderr; };
- throw this; // we throw self...
- }
+ if (this.cfg.exceptions && this.result != 0) {
+ var errstr = string.joinv(" ", this.cfg.args) + "\n";
+ errstr += this.output;
+ errstr += this.output.length > 0 ? "\n" : "";
+ errstr += this.stderr;
+ //print("Throwing execute error:%s\n", errstr);
+ throw new SpawnError.EXECUTE_ERROR(errstr);
+ //this.toString = function() { return this.stderr; };
+ ///throw new Exception this; // we throw self...
+ }
// finally throw, or return self..
+ return;
+
+ }
+
+ void on_child_watch(GLib.Pid w_pid, int result) {
+
+ this.result = result;
+ if (this.cfg.debug) {
+ stdout.printf("child_watch_add : result:%d\n", result);
+ }
+
+ this.read(this.out_ch);
+ this.read(this.err_ch);
+
+
+ Process.close_pid(this.pid);
+ this.pid = -1;
+ if (this.ctx != null) {
+ this.ctx.quit();
+ this.ctx = null;
+
+ }
+ //print("child process done - running callback, then tidyup");
+ this.on_finished(this.result, this.output + (this.output.length > 0 ? "\n" : "") + this.stderr);
+ // this.unref();
+ this.tidyup();
+
+ //print("DONE TIDYUP");
+
+
+ }
- return this;
- },
+
+ private void tidyup()
+ {
+ if (this.cfg.debug) {
+ GLib.debug("tidyup");
+ }
+
+ //print("Tidyup\n");
+ if (this.pid > -1) {
+ Process.close_pid(this.pid); // hopefully kills it..
+ this.pid = -1;
+ }
+ try {
+ if (this.in_ch != null) this.in_ch.shutdown(true);
+ if (this.out_ch != null) this.out_ch.shutdown(true);
+ if (this.err_ch != null) this.err_ch.shutdown(true);
+ } catch (Error e) {
+ // error shutting down
+ }
+ // blank out channels
+ this.in_ch = null;
+ this.err_ch = null;
+ this.out_ch = null;
+ // rmeove listeners !! important otherwise we kill the CPU
+ //if (this.err_src > -1 ) GLib.source_remove(this.err_src);
+ //if (this.out_src > -1 ) GLib.source_remove(this.out_src);
+ this.err_src = -1;
+ this.out_src = -1;
+ //this.unref();
+ }
+
+
/**
* write to stdin of process
* @arg str {String} string to write to stdin of process
* @returns GLib.IOStatus (0 == error, 1= NORMAL)
*/
- write : function(str) // write a line to
+ private int write(string str) throws Error // write a line to
{
- if (!this.in_ch) {
+ if (this.in_ch == null) {
return 0; // input is closed
}
- //print("write: " + str);
- // NEEDS GIR FIX! for return value.. let's ignore for the time being..
- //var ret = {};
- //var res = this.in_ch.write_chars(str, str.length, ret);
- var res = this.in_ch.write_chars(str, str.length);
-
- //print("write_char retunred:" + JSON.stringify(res) + ' ' +JSON.stringify(ret) );
-
+ //print("write: " + str);
+ // NEEDS GIR FIX! for return value.. let's ignore for the time being..
+ //var ret = {};
+ size_t written;
+ var res = this.in_ch.write_chars(str.to_utf8(), out written);
+
+ //print("write_char retunred:" + JSON.stringify(res) + ' ' +JSON.stringify(ret) );
+
if (res != GLib.IOStatus.NORMAL) {
- throw "Write failed";
+ throw new SpawnError.WRITE_ERROR("Write failed");
}
//return ret.value;
return str.length;
- },
+ }
+
/**
* read from pipe and call appropriate listerner and add to output or stderr string.
* @arg giochannel to read from.
* @returns none
*/
- read: function(ch)
+ private bool read(IOChannel ch)
{
- var prop = ch == this.out_ch ? 'output' : 'stderr';
+ string prop = (ch == this.out_ch) ? "output" : "stderr";
// print("prop: " + prop);
- var _this = this;
+ //print ("spawn.read: %s\n", prop);
-
//print(JSON.stringify(ch, null,4));
while (true) {
-
- var x = {};
- var status = ch.read_line( x);
+ string buffer;
+ size_t term_pos;
+ size_t len;
+ IOStatus status;
+
+ if (this.pid < 0) {
+ return false; // spawn complete + closed... can't read any more.
+ }
+
+ try {
+ var cond = ch.get_buffer_condition();
+ //if ((cond & GLib.IOCondition.ERR) > 0) {
+ // return false;
+ //}
+ //if ((cond & GLib.IOCondition.IN) < 1) {
+ // return false;
+ //}
+ status = ch.read_line( out buffer, out len, out term_pos );
+ } catch (Error e) {
+ //FIXme
+ return false;
+
+ }
+ if (buffer == null) {
+ return false;
+ }
+ //print("got buffer of %s\n", buffer);
// print('status: ' +JSON.stringify(status));
// print(JSON.stringify(x));
switch(status) {
case GLib.IOStatus.NORMAL:
//write(fn, x.str);
- if (this.listeners[prop]) {
- this.listeners[prop].call(this, x.str_return);
- }
- _this[prop] += x.str_return;
- if (_this.debug) {
- print(prop + ':' + x.str_return.replace(/\n/, ''));
+
+ //if (this.listeners[prop]) {
+ // this.listeners[prop].call(this, x.str_return);
+ //}
+ if (ch == this.out_ch) {
+ this.output += buffer;
+ if (this.cfg.output != null) {
+ this.cfg.output( buffer);
+ }
+ } else {
+ this.stderr += buffer;
}
- if (this.async) {
- try {
- if (imports.gi.Gtk.events_pending()) {
- imports.gi.Gtk.main_iteration();
- }
- } catch(e) {
-
+ //_this[prop] += x.str_return;
+ //if (this.cfg.debug) {
+ // stdout.printf("%s : %s", prop , buffer);
+ //}
+ if (this.cfg.async) {
+
+ if ( Gtk.events_pending()) {
+ Gtk.main_iteration();
}
}
continue;
case GLib.IOStatus.AGAIN:
//print("Should be called again.. waiting for more data..");
- return true;
- break;
+ return true;
+ //break;
case GLib.IOStatus.ERROR:
case GLib.IOStatus.EOF:
- return false;
- break;
+ return false;
+ //break;
}
break;
return false; // allow it to be called again..
}
-};
-/**
- * @function run
- *
- * simple run a process - returns result, or throws stderr result...
- * @param cfg {Object} see spawn
- * @return {string} stdout output.
- */
-function run(cfg) {
- cfg.exceptions = true;
- cfg.async = false;
- var s = new Spawn(cfg);
- var ret = s.run();
- return s.output;
}
- /*
+ /*
// test
try {
Seed.print(run({