///using Gee; // for array list?
-
+/*
static int main (string[] args) {
// A reference to our file
var cfg = new SpawnConfig("", { "ls" } , { "" });
- var spawn = new Spawn(cfg);
-
+ 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;
public delegate void SpawnOutput(string line);
public delegate void SpawnErr(string line);
public delegate string SpawnInput();
-
+public delegate void SpawnFinish(int result);
public class SpawnConfig {
public SpawnOutput output;
public SpawnErr stderr;
public SpawnInput input;
+ public SpawnFinish finish;
// defaults..
public SpawnConfig(string cwd,
string[] args,
this.env = env;
async = false;
- exceptions = false;
+ exceptions = true;
debug = false;
output = null;
input = null;
}
-
- public void setOptions(
- bool async,
- bool exceptions,
- bool debug
- ) {
- this.async = async;
- this.exceptions = exceptions;
- this.debug = debug;
- }
+
+
public void setHandlers(
- SpawnOutput output,
- SpawnErr stderr,
- SpawnInput input
+ SpawnOutput? output,
+ SpawnErr? stderr,
+ SpawnInput? input,
+ SpawnFinish? finish
) {
this.output = output;
this.stderr = stderr;
this.input = input;
+ this.finish = finish;
}
}
-errordomain SpawnError {
- NO_ARGS
+public errordomain SpawnError {
+ NO_ARGS,
+ WRITE_ERROR,
+ EXECUTE_ERROR
+
}
/**
this.cfg = cfg;
-
+ this.output = "";
+ this.stderr = "";
this.cfg.cwd = this.cfg.cwd.length < 1 ? GLib.Environment.get_home_dir() : this.cfg.cwd;
if (this.cfg.args.length < 0) {
/**
* @property output {String} resulting output
*/
- string output = "";
+ public string output;
/**
* @property stderr {String} resulting output from stderr
*/
- string stderr = "";
+ public string stderr;
/**
* @property result {Number} execution result.
*/
*
* @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.
*/
- public void run()
+ public void run() throws SpawnError, GLib.SpawnError, GLib.IOChannelError
{
- var err_src = false;
- var out_src = false;
+ err_src = -1;
+ out_src = -1;
int standard_input;
int standard_output;
int standard_error;
out this.pid,
out standard_input,
out standard_output,
- out standard_error);
+ out standard_error);
// stdout:
stdout.printf("PID: %d" ,this.pid);
}
-
+
+ this.ref(); // additional ref - cleared on tidyup...
+
+ 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);
+
+
+
+
ChildWatch.add (this.pid, (w_pid, result) => {
this.result = result;
}
this.tidyup();
//print("DONE TIDYUP");
- if (this.cfg.finish) {
+ if (this.cfg.finish != null) {
this.cfg.finish(this.result);
}
});
- 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);
-
-
+
// add handlers for output and stderr.
- this.out_src = this.out_ch.add_watch (
+ this.out_src = (int) this.out_ch.add_watch (
IOCondition.OUT | IOCondition.IN | IOCondition.PRI | IOCondition.HUP | IOCondition.ERR ,
(channel, condition) => {
- return this.read(_this.out_ch);
+ return this.out_ch != null ? this.read(this.out_ch) : true;
}
);
- this.err_src = this.err_ch.add_watch (
- IOCondition.OUT | IOCondition.IN | IOCondition.PRI | IOCondition.HUP | IOCondition.ERR ,
+ this.err_src = (int) this.err_ch.add_watch (
+ IOCondition.OUT | IOCondition.IN | IOCondition.PRI | IOCondition.HUP | IOCondition.ERR ,
(channel, condition) => {
- return this.read(_this.err_ch);
+ return this.read(this.err_ch);
}
);
// call input..
if (this.pid > -1) {
- // child can exit before 1we get this far..
+ // child can exit before we get this far..
if (this.cfg.input != null) {
- if (this.cfg.debug) print("Trying to call listeners");
+ if (this.cfg.debug) print("Trying to call listeners");
try {
this.write(this.cfg.input());
- // this probably needs to be a bit smarter...
- //but... let's close input now..
- this.in_ch.close();
- this.in_ch = -1;
-
-
+ // 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();
- throw e;
+ return;
+ // throw e;
}
}
+
}
- // async - if running - return..
+ // async - if running - return..
if (this.cfg.async && this.pid > -1) {
return;
}
// start mainloop if not async..
if (this.pid > -1) {
- if (this.cfg.debug) {
- print("starting main loop");
- }
- this.ctx = new MainLoop ();
- loop.run(); // wait fore exit?
+ print("starting main loop");
+ //if (this.cfg.debug) {
+ //
+ // }
+ this.ctx = new MainLoop ();
+ this.ctx.run(); // wait fore exit?
- //print("main_loop done!");
+ print("main_loop done!");
} else {
this.tidyup(); // tidyup get's called in main loop.
}
if (this.cfg.exceptions && this.result != 0) {
+
+ throw new SpawnError.EXECUTE_ERROR(this.stderr);
//this.toString = function() { return this.stderr; };
///throw new Exception this; // we throw self...
}
private void tidyup()
{
+ this.unref();
if (this.pid > -1) {
Process.close_pid(this.pid); // hopefully kills it..
this.pid = -1;
* @arg str {String} string to write to stdin of process
* @returns GLib.IOStatus (0 == error, 1= NORMAL)
*/
- private int write(string str) // write a line to
+ private int write(string str) throws Error // write a line to
{
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);
+ 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.
{
string prop = (ch == this.out_ch) ? "output" : "stderr";
// print("prop: " + prop);
- var _this = this;
- string str_return;
+
//print(JSON.stringify(ch, null,4));
while (true) {
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
- break; // ??
+ return false;
}
+
// 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);
//}
if (ch == this.out_ch) {
this.output += buffer;
+ if (this.cfg.output != null) {
+ this.cfg.output( buffer);
+ }
} else {
this.stderr += buffer;
}
//_this[prop] += x.str_return;
- if (this.cfg.debug) {
- stdout.printf("%s : %s", prop , str_return);
- }
+ //if (this.cfg.debug) {
+ stdout.printf("%s : %s", prop , buffer);
+ //}
if (this.cfg.async) {
- try {
- if ( Gtk.events_pending()) {
- Gtk.main_iteration();
- }
- } catch(Error e) {
-
+
+ if ( Gtk.events_pending()) {
+ Gtk.main_iteration();
}
+
}
//this.ctx.iteration(true);
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;