git.roojs.org Git - gitlive/blob - Spawn.vala

   1
   2
   3 using GLib;
   4 // compile valac
   5
   6 /// # valac  --pkg gio-2.0  --pkg posix Spawn.vala -o /tmp/Spawn
   7
   8
   9 ///using Gee; // for array list?
  10
  11 static int main (string[] args) {
  12     // A reference to our file
  13
  14     var cfg = new SpawnConfig("", { "ls" } , { "" });
  15     var spawn = new Spawn(cfg);
  16
  17
  18     return 0;
  19
  20 }
  21
  22 //var Gio      = imports.gi.Gio;
  23 //var GLib      = imports.gi.GLib;
  24
  25
  26 /**
  27 * @namespace Spawn
  28 *
  29 * Library to wrap GLib.spawn_async_with_pipes
  30 *
  31 * usage:
  32 * v
  33 *
  34 *var output = new Spawn( SpawnConfig() {
  35     cwd = "/home",  // empty string to default to homedirectory.
  36     args = {"ls", "-l" },
  37     evn = {},
  38     ouput  = (line) => { stdout.printf("%d\n", line); }
  39     stderr  = (line) => { stdout.printf("%d\n", line); }
  40     input  = () => { return "xxx"; }
  41 };
  42 *
  43 *
  44 */
  45 public delegate void SpawnOutput(string line);
  46 public delegate void SpawnErr(string line);
  47 public delegate string SpawnInput();
  48
  49
  50
  51 public class  SpawnConfig {
  52     public string cwd;
  53     public string[] args;
  54     public string[]  env;
  55     public bool async;
  56     public bool exceptions; // fire exceptions.
  57     public bool debug; // fire exceptions.
  58
  59     public SpawnOutput output;
  60     public SpawnErr stderr;
  61     public SpawnInput input;
  62     // defaults..
  63     public SpawnConfig(string cwd,
  64             string[] args,
  65             string[] env
  66         ) {
  67         this.cwd = cwd;
  68         this.args = args;
  69         this.env = env;
  70
  71         async = false;
  72         exceptions = false;
  73         debug = false;
  74
  75         output = null;
  76         stderr = null;
  77         input = null;
  78
  79     }
  80
  81     public void setOptions(
  82             bool async,
  83             bool exceptions,
  84             bool debug
  85         ) {
  86         this.async = async;
  87         this.exceptions = exceptions;
  88         this.debug = debug;
  89     }
  90     public void setHandlers(
  91             SpawnOutput output,
  92             SpawnErr stderr,
  93             SpawnInput input
  94          ) {
  95         this.output = output;
  96         this.stderr = stderr;
  97         this.input = input;
  98     }
  99
 100
 101 }
 102
 103 errordomain SpawnError {
 104     NO_ARGS
 105 }
 106
 107 /**
 108  * @class Spawn
 109  * @param cfg {SpawnConfig} settings - see properties.
 110  *
 111  * @arg cwd {String}            working directory. (defaults to home directory)
 112  * @arg args {Array}            arguments eg. [ 'ls', '-l' ]
 113  * @arg listeners {Object} (optional) handlers for output, stderr, input
 114  *     stderr/output both receive output line as argument
 115  *     input should return any standard input
 116  *     finish recieves result as argument.
 117  * @arg env {Array}             enviroment eg. [ 'GITDIR=/home/test' ]
 118  * @arg async {Boolean} (optional)return instantly, or wait for exit. (default no)
 119  * @arg exceptions {Boolean}    throw exception on failure (default no)
 120  * @arg debug {Boolean}    print out what's going on.. (default no)
 121  *
 122  */
 123
 124
 125 public class Spawn : Object
 126 {
 127
 128     SpawnConfig cfg;
 129
 130     public Spawn(SpawnConfig cfg) throws Error
 131     {
 132
 133
 134         this.cfg = cfg;
 135
 136
 137         this.cfg.cwd =  this.cfg.cwd.length  < 1 ? GLib.Environment.get_home_dir() : this.cfg.cwd;
 138         if (this.cfg.args.length < 0) {
 139             throw new SpawnError.NO_ARGS("No arguments");
 140         }
 141         this.run();
 142
 143     }
 144
 145
 146     bool ctx = false; // the mainloop ctx.
 147
 148     /**
 149      * @property output {String} resulting output
 150      */
 151     string output  = "";
 152     /**
 153      * @property stderr {String} resulting output from stderr
 154      */
 155     string stderr  = "";
 156      /**
 157      * @property result {Number} execution result.
 158      */
 159     int result= 0;
 160     /**
 161      * @property pid {Number} pid of child process (of false if it's not running)
 162      */
 163     int  pid = -1;
 164     /**
 165      * @property in_ch {GLib.IOChannel} input io channel
 166      */
 167     IOChannel in_ch = null;
 168     /**
 169      * @property out_ch {GLib.IOChannel} output io channel
 170      */
 171     IOChannel out_ch = null;
 172     /**
 173      * @property err_ch {GLib.IOChannel} stderr io channel
 174      */
 175     IOChannel err_ch = null;
 176     /**
 177      * @property err_src {int} the watch for errors
 178      */
 179
 180     int err_src = -1;
 181       /**
 182      * @property err_src {int} the watch for output
 183      */
 184     int out_src = -1;
 185
 186     /**
 187      *
 188      * @method run
 189      * Run the configured command.
 190      * result is applied to object properties (eg. 'output' or 'stderr')
 191      * @returns {Object} self.
 192      */
 193     public void run()
 194     {
 195
 196
 197         var err_src = false;
 198         var out_src = false;
 199         int standard_input;
 200         int standard_output;
 201         int standard_error;
 202
 203
 204
 205         if (this.cfg.debug) {
 206             printf("cd %s; %s" , this.cfg.cwd , string.joinv(" ", this.cfg.args));
 207         }
 208
 209         Process.spawn_async_with_pipes (
 210                 this.cfg.cwd,
 211                 this.cfg.args,
 212                 this.cfg.env,
 213                 SpawnFlags.SEARCH_PATH | SpawnFlags.DO_NOT_REAP_CHILD,
 214                 null,
 215                 out this.pid,
 216                 out standard_input,
 217                 out standard_output,
 218                         out standard_error);
 219
 220                 // stdout:
 221
 222
 223         //print(JSON.stringify(gret));
 224
 225         if (this.cfg.debug) {
 226             print("PID: " + this.pid);
 227         }
 228
 229         ChildWatch.add (this.pid, (w_pid, result) => {
 230
 231             this.result = result;
 232             if (_this.debug) {
 233                 print("child_watch_add : result: " + result);
 234             }
 235
 236             this.read(this.out_ch);
 237             this.read(this.err_ch);
 238
 239
 240             Process.close_pid(this.pid);
 241             this.pid = -1;
 242             if (this.ctx) {
 243                 this.ctx.quit();
 244             }
 245             this.tidyup();
 246             //print("DONE TIDYUP");
 247             if (this.cfg.finish) {
 248                 this.cfg.finish(this.result);
 249             }
 250         });
 251
 252
 253
 254
 255         this.in_ch = new GLib.IOChannel.unix_new(standard_input);
 256         this.out_ch = new GLib.IOChannel.unix_new(standard_output);
 257         this.err_ch = new GLib.IOChannel.unix_new(standard_error);
 258
 259         // make everything non-blocking!
 260
 261
 262
 263                   // using NONBLOCKING only works if io_add_watch
 264           //returns true/false in right conditions
 265           this.in_ch.set_flags (GLib.IOFlags.NONBLOCK);
 266           this.out_ch.set_flags (GLib.IOFlags.NONBLOCK);
 267           this.err_ch.set_flags (GLib.IOFlags.NONBLOCK);
 268
 269
 270
 271             // add handlers for output and stderr.
 272
 273         this.out_src = this.out_ch.add_watch (
 274             IOCondition.OUT | IOCondition.IN  | IOCondition.PRI |  IOCondition.HUP |  IOCondition.ERR  ,
 275             (channel, condition) => {
 276                return this.read(_this.out_ch);
 277             }
 278         );
 279         this.err_src = this.err_ch.add_watch (
 280             IOCondition.OUT | IOCondition.IN  | IOCondition.PRI |  IOCondition.HUP |  IOCondition.ERR  ,
 281             (channel, condition) => {
 282                return this.read(_this.err_ch);
 283             }
 284         );
 285
 286
 287         // call input..
 288         if (this.pid > -1) {
 289             // child can exit before 1we get this far..
 290             if (this.cfg.input != null) {
 291                 if (this.cfg.debug) print("Trying to call listeners");
 292                 try {
 293                     this.write(this.cfg.input());
 294                      // this probably needs to be a bit smarter...
 295                     //but... let's close input now..
 296                     this.in_ch.close();
 297                     this.in_ch = -1;
 298
 299
 300                 } catch (Error e) {
 301                     this.tidyup();
 302                     throw e;
 303
 304                 }
 305
 306             }
 307         }
 308         // async - if running - return..
 309         if (this.cfg.async && this.pid > -1) {
 310             return;
 311         }
 312
 313         // start mainloop if not async..
 314
 315         if (this.pid > -1) {
 316             if (this.cfg.debug) {
 317                 print("starting main loop");
 318             }
 319             this.ctx = new MainLoop ();
 320             loop.run(); // wait fore exit?
 321
 322             //print("main_loop done!");
 323         } else {
 324             this.tidyup(); // tidyup get's called in main loop.
 325         }
 326
 327         if (this.cfg.exceptions && this.result != 0) {
 328             //this.toString = function() { return this.stderr; };
 329             ///throw new Exception this; // we throw self...
 330         }
 331
 332         // finally throw, or return self..
 333
 334         return;
 335
 336     }
 337
 338
 339
 340     private void tidyup()
 341     {
 342         if (this.pid > -1) {
 343             Process.close_pid(this.pid); // hopefully kills it..
 344             this.pid = -1;
 345         }
 346         if (this.in_ch)  this.in_ch.close();
 347         if (this.out_ch)  this.out_ch.close();
 348         if (this.err_ch)  this.err_ch.close();
 349         // blank out channels
 350         this.in_ch = false;
 351         this.err_ch = false;
 352         this.out_ch = false;
 353         // rmeove listeners !! important otherwise we kill the CPU
 354         if (this.err_src > -1 ) GLib.source_remove(this.err_src);
 355         if (this.out_src > -1 ) GLib.source_remove(this.out_src);
 356         this.err_src = -1;
 357         this.out_src = -1;
 358
 359     }
 360
 361
 362     /**
 363      * write to stdin of process
 364      * @arg str {String} string to write to stdin of process
 365      * @returns GLib.IOStatus (0 == error, 1= NORMAL)
 366      */
 367     private int write(string str) // write a line to
 368     {
 369         if (this.in_ch == null) {
 370             return 0; // input is closed
 371         }
 372         //print("write: " + str);
 373         // NEEDS GIR FIX! for return value.. let's ignore for the time being..
 374         //var ret = {};
 375             //var res = this.in_ch.write_chars(str, str.length, ret);
 376         var res = this.in_ch.write_chars(str, str.length);
 377
 378         //print("write_char retunred:" + JSON.stringify(res) +  ' ' +JSON.stringify(ret)  );
 379
 380             if (res != GLib.IOStatus.NORMAL) {
 381                 throw "Write failed";
 382         }
 383         //return ret.value;
 384         return str.length;
 385
 386     }
 387
 388     /**
 389      * read from pipe and call appropriate listerner and add to output or stderr string.
 390      * @arg giochannel to read from.
 391      * @returns none
 392      */
 393     private bool read(IOChannel ch)
 394     {
 395         string prop = (ch == this.out_ch) ? "output" : "stderr";
 396        // print("prop: " + prop);
 397         var _this = this;
 398
 399
 400         //print(JSON.stringify(ch, null,4));
 401         while (true) {
 402
 403             var x =   {};
 404             var status = ch.read_line( x);
 405             // print('status: '  +JSON.stringify(status));
 406             // print(JSON.stringify(x));
 407              switch(status) {
 408                 case GLib.IOStatus.NORMAL:
 409
 410                     //write(fn, x.str);
 411                     if (this.listeners[prop]) {
 412                         this.listeners[prop].call(this, x.str_return);
 413                     }
 414                     _this[prop] += x.str_return;
 415                     if (_this.debug) {
 416                         print(prop + ':' + x.str_return.replace(/\n/, ''));
 417                     }
 418                     if (this.async) {
 419                         try {
 420                             if (imports.gi.Gtk.events_pending()) {
 421                                 imports.gi.Gtk.main_iteration();
 422                             }
 423                         } catch(Error e) {
 424
 425                         }
 426                     }
 427
 428                     //this.ctx.iteration(true);
 429                    continue;
 430                 case GLib.IOStatus.AGAIN:
 431                     //print("Should be called again.. waiting for more data..");
 432                     return true;
 433                     break;
 434                 case GLib.IOStatus.ERROR:
 435                 case GLib.IOStatus.EOF:
 436                     return false;
 437                    break;
 438
 439             }
 440             break;
 441         }
 442
 443         //print("RETURNING");
 444          return false; // allow it to be called again..
 445     }
 446
 447 }
 448   /*
 449 // test
 450 try {
 451     Seed.print(run({
 452         args: ['ls', '/tmp'],
 453         debug : true
 454     }));
 455 } catch (e) { print(JSON.stringify(e)); }
 456
 457 var secs = (new Date()).getSeconds()
 458
 459 try {
 460 Seed.print(run({
 461     args: ['/bin/touch', '/tmp/spawntest-' + secs ],
 462     debug : true
 463 }));
 464 } catch (e) { print( 'Error: ' + JSON.stringify(e)); }
 465
 466
 467  */
 468