Gnome shell extensions: how to run a command with pipes

Question

So I'm making a Gnome Shell extension. And I want to be able to run some command with a pipe. (The command is actually "xrandr --query | awk 'something'", but that is off topic)

So, what I have done so far is

GLib.spawn_async_with_pipes(null,
                            ['/usr/bin/xrandr', '--query', '|', 'awk...'], null,
                            GLib.SpawnFlags.DO_NOT_REAP_CHILD, null);

But it doesn't work! I can't find any example of running a command in a gnome extensions with a pipe.

Do I have to write "|" in the command like I did ?

Answer 1

spawn_async_with_pipes doesn't do what you want (in a simple way). It return the pipes to process with it. You could do it with two call and connecting but it will be a little bit complex.

A simple way to keep the exact syntax is to call a shell which will do the pipe processing with the help of this answer which give a way to call a command, I wrote the following code which call the shell (bash for this case) with correct arguments

const Util = imports.misc.util;
Util.spawn(['/bin/bash', '-c', "xrandr --query | awk 'something'"])

Answer 2

I implemented a TerminalReader class some time ago in a Cinnamon Applet: https://github.com/lestcape/Configurable-Menu/blob/OwnAPI/configurableMenu%40lestcape/pakagesManager.js#L31

This class is now used in other places also, so you have more examples to underestand it better: https://github.com/search?l=JavaScript&q=TerminalReader&type=Code&utf8=%E2%9C%93

Here is the source code of the class:

function TerminalReader() {
    this._init.apply(this, arguments);
}

TerminalReader.prototype = {
_init: function(command, callback) {
    this._callbackPipe = callback;
    this._commandPipe = command;
    this.idle = true;
    this._childWatch = null;
},

executeReader: function() {
    if(this.idle) {
        this.idle = false;
        try {
            let [success, argv] = GLib.shell_parse_argv("sh -c '" + this._commandPipe + "'");
            if(success) {
                let [exit, pid, stdin, stdout, stderr] =
                  GLib.spawn_async_with_pipes(
                      null, // cwd
                      argv, // args
                      null, // env
                      GLib.SpawnFlags.SEARCH_PATH | GLib.SpawnFlags.DO_NOT_REAP_CHILD, //Use env path and no repet
                      null // child_setup
                  );

                this._childPid = pid;
                this._stdin = new Gio.UnixOutputStream({ fd: stdin, close_fd: true });
                this._stdout = new Gio.UnixInputStream({ fd: stdout, close_fd: true });
                this._stderr = new Gio.UnixInputStream({ fd: stderr, close_fd: true });

                // We need this one too, even if don't actually care of what the process
                // has to say on stderr, because otherwise the fd opened by g_spawn_async_with_pipes
                // is kept open indefinitely
                this._stderrStream = new Gio.DataInputStream({ base_stream: this._stderr });
                this._dataStdout = new Gio.DataInputStream({ base_stream: this._stdout });
                this._cancellableStderrStream = new Gio.Cancellable();
                this._cancellableStdout = new Gio.Cancellable();

                this.resOut = 1;
                this._readStdout();
                this.resErr = 1;
                this._readStderror();

                this._childWatch = GLib.child_watch_add(GLib.PRIORITY_DEFAULT, pid, Lang.bind(this, function(pid, status, requestObj) {
                    GLib.source_remove(this._childWatch);
                    this._childWatch = null;
                    this._stdin.close(null);
                    this.idle = true;
                }));
            }
            //throw
        } catch(err) {
            if(err.code == GLib.SpawnError.G_SPAWN_ERROR_NOENT) {
                err.message = _("Command not found.");
            } else {
                // The exception from gjs contains an error string like:
                //   Error invoking GLib.spawn_command_line_async: Failed to
                //   execute child process "foo" (No such file or directory)
                // We are only interested in the part in the parentheses. (And
                // we can't pattern match the text, since it gets localized.)
                err.message = err.message.replace(/.*\((.+)\)/, '$1');
            }
            throw err;
        }
    }
},

destroy: function() {
    try {
        if(this._childWatch) {
            GLib.source_remove(this._childWatch);
            this._childWatch = null;
        }
        if(!this._dataStdout.is_closed()) {
            this._cancellableStdout.cancel();
            this._stdout.close_async(0, null, Lang.bind(this, this.closeStdout));
        }
        if(!this._stderrStream.is_closed()) {
            this._cancellableStderrStream.cancel();
            this._stderrStream.close_async(0, null, Lang.bind(this, this.closeStderrStream));
        }
        this._stdin.close(null);
        this.idle = true;
    }
    catch(e) {
        Main.notify("Error on close" + this._dataStdout.is_closed(), e.message);
    }
},

closeStderrStream: function(std, result) {
    try {
        std.close_finish(result);
    } catch(e) {
        std.close_async(0, null, Lang.bind(this, this.closeStderrStream));
    }
},

closeStdout: function(std, result) {
    try {
        std.close_finish(result);
    } catch(e) {
        std.close_async(0, null, Lang.bind(this, this.closeStderrStream));
    }
},

_readStdout: function() {
    this._dataStdout.fill_async(-1, GLib.PRIORITY_DEFAULT, this._cancellableStdout, Lang.bind(this, function(stream, result) {
        try {
            if(!this._dataStdout.is_closed()) {
                if(this.resOut != -1)
                    this.resOut = this._dataStdout.fill_finish(result);// end of file
                if(this.resOut == 0) {
                    let val = stream.peek_buffer().toString();
                    if(val != "")
                        this._callbackPipe(this._commandPipe, true, val);
                    this._stdout.close(this._cancellableStdout);
                } else {
                    // Try to read more
                    this._dataStdout.set_buffer_size(2 * this._dataStdout.get_buffer_size());
                    this._readStdout();
                }
            }
        } catch(e) {
            global.log(e.toString());
        }
    }));
},

_readStderror: function() {
    this._stderrStream.fill_async(-1, GLib.PRIORITY_DEFAULT, this._cancellableStderrStream, Lang.bind(this, function(stream, result) {
        try {
            if(!this._stderrStream.is_closed()) {
                if(this.resErr != -1)
                    this.resErr = this._stderrStream.fill_finish(result);
                if(this.resErr == 0) { // end of file
                    let val = stream.peek_buffer().toString();
                    if(val != "")
                        this._callbackPipe(this._commandPipe, false, val);
                    this._stderr.close(null);
                } else {
                    this._stderrStream.set_buffer_size(2 * this._stderrStream.get_buffer_size());
                    this._readStderror();
                }
            }
        } catch(e) {
            global.log(e.toString());
        }
    }));
}
};