/**
* Revised version?
*
- * x = new Spawn( working dir, args)
+ * x = new Spawn( "/tmp", {"ls", "-l" })
+ *
+ * // these are optionall..
* x.env = ..... (if you need to set one...
- * x.output_line.connect((string str) => { ... });
+ * x.output_line.connect((string str) => {
+ * if ( Gtk.events_pending()) { Gtk.main_iteration(); }
+ * });
* x.input_line.connect(() => { return string });
- * x.finish.connect((int res, string output, string stderr) => { ... });
- * x.run();
+ *
+ * x.run((int res, string output, string stderr) => { ... });
+
*
*
*/
/**
* @class Spawn
- * @param cfg {SpawnConfig} settings - see properties.
+ * @param cwd {String} working directory. (defaults to home directory)
+ * @param args {Array} arguments eg. [ 'ls', '-l' ]
*
- * @arg cwd {String} working directory. (defaults to home directory)
- * @arg args {Array} arguments eg. [ 'ls', '-l' ]
- * @arg listeners {Object} (optional) handlers for output, stderr, input
- * stderr/output both receive output line as argument
- * input should return any standard input
- * finish recieves result as argument.
+
* @arg env {Array} enviroment eg. [ 'GITDIR=/home/test' ]
- * @arg async {Boolean} (optional)return instantly, or wait for exit. (default no)
- * @arg exceptions {Boolean} throw exception on failure (default no)
- * @arg debug {Boolean} print out what's going on.. (default no)
+ * @arg is_async {Boolean} (optional)return instantly, or wait for exit. (default no)
+ * @arg trhow_exceptions {Boolean} throw exception on failure (default no)
+
*
*/
-
-
+
public class Spawn : Object
{
+ /**
+ * @signal input called at start to send input when process starts?
+ * @return the string or null
+ */
public signal string? input();
+ /**
+ * @signal complete called at when the command has completed.
+ *
+ */
+ public signal void complete(int res, string str, string stderr);
+ /**
+ * @signal output_line called when a line is recieved from the process.
+ * Note you may want to connect this and run
+ * if ( Gtk.events_pending()) { Gtk.main_iteration(); }
+ *
+ * @param {string} str
+ */
public signal void output_line(string str);
- public signal void finish(int res, string str, string stderr);
-
+
public string cwd;
public string[] args;
public string[] env;
- public bool debug = false;
+
public bool is_async = true;
public bool throw_exceptions = false;
+ public bool detach = false;
public Spawn(string cwd, string[] args) throws Error
{
/**
* @property result {Number} execution result.
*/
- int result= 0;
+ public int result= 0;
/**
* @property pid {Number} pid of child process (of false if it's not running)
*/
* result is applied to object properties (eg. '?' or 'stderr')
* @returns {Object} self.
*/
- public void run() throws SpawnError, GLib.SpawnError, GLib.IOChannelError
+ public void run( ) throws SpawnError, GLib.SpawnError, GLib.IOChannelError
{
GLib.debug("cd %s; %s" , this.cwd , string.joinv(" ", this.args));
-
+ if (this.detach) {
+ Process.spawn_async_with_pipes (
+ this.cwd,
+ this.args,
+ this.env.length > 0 ? this.env : null,
+ SpawnFlags.SEARCH_PATH | SpawnFlags.DO_NOT_REAP_CHILD,
+ null,
+ out this.pid);
+ ChildWatch.add (this.pid, (pid, status) => {
+ // Triggered when the child indicated by child_pid exits
+ Process.close_pid (pid);
+
+ });
+
+ return;
+
+ }
Process.spawn_async_with_pipes (
this.cwd,
this.args,
- this.env,
+ this.env.length > 0 ? this.env : null,
SpawnFlags.SEARCH_PATH | SpawnFlags.DO_NOT_REAP_CHILD,
null,
out this.pid,
out standard_error);
// stdout:
-
+
//print(JSON.stringify(gret));
this.tidyup();
//print("DONE TIDYUP");
- this.finish(this.result, this.output, this.stderr);
+ this.complete(this.result, this.output, this.stderr);
});
*/
private bool read(IOChannel ch)
{
- string prop = (ch == this.out_ch) ? "output" : "stderr";
+ // string prop = (ch == this.out_ch) ? "output" : "stderr";
// print("prop: " + prop);
//}
if (ch == this.out_ch) {
this.output += buffer;
- this.line_output( buffer);
+ this.output_line( buffer);
} else {
this.stderr += buffer;
+ this.output_line( buffer);
}
//_this[prop] += x.str_return;
//if (this.cfg.debug) {
- GLib.debug("%s : %s", prop , buffer);
+ //GLib.debug("%s : %s", prop , buffer);
//}
- if (this.cfg.async) {
+ if (this.is_async) {
- if ( Gtk.events_pending()) {
- Gtk.main_iteration();
- }
+ //if ( Gtk.events_pending()) {
+ // Gtk.main_iteration();
+ //}
}
}
}
-
+/*
int main (string[] args) {
+ GLib.Log.set_handler(null,
+ GLib.LogLevelFlags.LEVEL_DEBUG | GLib.LogLevelFlags.LEVEL_WARNING,
+ (dom, lvl, msg) => {
+ print("%s: %s\n", dom, msg);
+ });
+
var ctx = new GLib.MainLoop ();
var a = new Spawn("", { "ls" , "-l"});
- a.finish.connect((res, str, stderr) => {
+ a.run((res, str, stderr) => {
print(str);
ctx.quit();
});
+
ctx.run(); // wait for exit?
return 0;
}
-
+ */