Ubuntu: Running a .desktop file in the terminal



Question:

From what I can gather, .desktop files are shortcuts that allow application's settings to be customized. For instance, I have lots of them in my /usr/share/applications/ folder.

If I open that folder in nautilus, I can run these applications just by double clicking its associated file, e.g. double-clicking firefox.desktop runs Firefox. However, I can't find a way to do the same thing via terminal.

If I do gnome-open foo.desktop it simply opens foo.desktop as a text file. If I make it executable and then run it in bash it simply fails (which is expected, it's clearly not bash script).
EDIT: Doing exec /fullpath/foo.desktop gives me a Permission denied message, even if I change ownership to myself. If I make executable and do the same command, the terminal tab I'm using simply closes (I'm guessing it crashes). Finally, if I do sudo exec /fullpath/foo.desktop, I get an error reporting sudo: exec: command not found.

That's my question, how can I run a foo.desktop file from the terminal?


Solution:1

The command that is run is contained inside the desktop file, preceded by Exec= so you could extract and run that by:

`grep '^Exec' filename.desktop | tail -1 | sed 's/^Exec=//' | sed 's/%.//' | sed 's/^"//g' | sed 's/" *$//g'` &  

To break that down

grep  '^Exec' filename.desktop    - finds the line which starts with Exec  | tail -1                         - only use the last line, in case there are multiple  | sed 's/^Exec=//'                - removes the Exec from the start of the line  | sed 's/%.//'                    - removes any arguments - %u, %f etc  | sed 's/^"//g' | sed 's/" *$//g' - removes " around command (if present)  `...`                             - means run the result of the command run here  &                                 - at the end means run it in the background  

You could put this in a file, say ~/bin/deskopen with the contents

#!/bin/sh  `grep '^Exec' $1 | tail -1 | sed 's/^Exec=//' | sed 's/%.//' | sed 's/^"//g' | sed 's/" *$//g'` &  

Then make it executable

chmod +x ~/bin/deskopen  

And then you could do, eg

deskopen /usr/share/applications/ubuntu-about.desktop  

The arguments (%u, %F etc) are detailed at http://standards.freedesktop.org/desktop-entry-spec/desktop-entry-spec-1.0.html#exec-variables - none of them are relevant for launching at the command line.


Solution:2

The answer should be

xdg-open program_name.desktop  

But due to a bug this no longer works.


Solution:3

As of today (12.10) the bug is still present. It is in fact depending on how gvfs-open (called by xdg-open) works.

Still, I managed a quick workaround (stealing inspiration from the nautilus source code). It is a bit convoluted, but works flawlessly on Ubuntu 12.10, adding a meaningful icon (no more ?) on the Unity launcher.

First, I wrote a python script using Gio and placed saved it as ~/bin/run-desktop :

#!/usr/bin/python    from gi.repository import Gio  import sys     def main(myname, desktop, *uris):      launcher = Gio.DesktopAppInfo.new_from_filename(desktop)      launcher.launch_uris(uris, None)    if __name__ == "__main__":      main(*sys.argv)  

The script needs to have the executable permission, so I ran this in a terminal:

chmod +x ~/bin/run-desktop  

Then I created the relative .desktop entry on ~/.local/share/applications/run-desktop.desktop:

[Desktop Entry]  Version=1.0  Name=run-desktop  Exec=run-desktop %U  MimeType=application/x-desktop  Terminal=false  Type=Application  

Finally I associated the entry as the default handler in ~/.local/share/applications/mimeapps.list under the [Default Applications] section as :

[Default Applications]  ....  application/x-desktop=run-desktop.desktop  

Now:

  • xdg-open something.desktop works as expected
  • #!/usr/bin/xdg-open hashbang on top of an executable desktop entry works too

It will be useless work when gvfs-open will solve the bug, but in the meantime...


Solution:4

With any recent ubuntu that supports gtk-launch just simply go

gtk-launch <file> where is the name of the .desktop file without the .desktop part

So gtk-launch foo opens foo.desktop

Usable from terminal or alt+F2 (alt+F2 stores command in history so easily accessible)


Solution:5

While OP was not asking about KDE, for anyone that is running KDE the following command can be used:

kioclient exec <path-to-desktop-file>


Solution:6

The Right Way

You should really be using gtk-launch if it is available. It is usually part of the package libgtk-3-bin (this may vary by distro).

gtk-launch is used as follows:

gtk-launch APPLICATION [URI...]  gtk-launch app-name.desktop  gtk-launch app-name  

Please note that gtk-launch requires the .desktop file to be installed (i.e. located in /usr/share/applications or ~/.local/share/applications).

So to get around this, we can use a hackish little Bash function that temporarily installs the desired .desktop file before launching it. The "correct" way to install a .desktop file is via desktop-file-install but I'm going to ignore that.

launch(){        # Usage: launch PATH [URI...]        # NOTE: The bulk of this function is executed in a subshell, i.e. `(..)`      #       This isn't strictly necessary, but it keeps everything      #       out of the global namespace and lessens the likelihood      #       of side effects.        (        # where you want to install the launcher to      appdir=$HOME/.local/share/applications        # the template used to install the launcher      template=launcher-XXXXXX.desktop        # ensure $1 has a .desktop extension, exists, is a normal file, is readable, has nonzero size      # optionally use desktop-file-validate for stricter checking      # desktop-file-validate "$1" 2>/dev/null || {      [[ $1 = *.desktop && -f $1 && -r $1 && -s $1 ]] || {          echo "ERROR: you have not supplied valid .desktop file" >&2          return 1      }        # ensure the temporary launcher is deleted upon exit      trap 'rm "$launcherfile" &>/dev/null' EXIT        # create a temp file to overwrite later      launcherfile=$(mktemp -p "$appdir" "$template")        launchername=${launcherfile##*/}        # overwrite temp file with the launcher file      if cp "$1" "$launcherfile" &>/dev/null; then          gtk-launch "$launchername" "${@:2}"      else          echo "ERROR: failed to copy launcher to applications directory" >&2          return 1      fi        )    }  

You can use it like so (and also pass along additional arguments or URIs if you want):

launch PATH [URI...]  launch ./path/to/shortcut.desktop  

The Manual Alternative

If you want to manually parse and execute a .desktop file, you can do so with the following awk command:

awk '/^Exec=/ {sub("^Exec=", ""); gsub(" ?%[cDdFfikmNnUuv]", ""); exit system($0)}' app-name.desktop  

If you want to treat the awk command like an all-in-one script; we can even show an error message and exit with a return code of 1 in the event that an Exec command is not found:

awk 'BEGIN {command=""} /^Exec=/ {sub("^Exec=", ""); gsub(" ?%[cDdFfikmNnUuv]", ""); command=$0; exit} END {if (command!="") {exit system(command)} else {if (FILENAME == "-") {printf "ERROR: Failed to identify Exec line\n" > "/dev/stderr"} else {printf "ERROR: Failed to identify Exec line in \047%s\047\n", FILENAME > "/dev/stderr"} close("/dev/stderr"); exit 1}}'  

The aforementioned commands will:

  1. Find the line starting with Exec=
  2. Remove Exec=
  3. Remove any Exec variables (e.g. %f, %u, %U). It is possible to replace these with positional arguments as the specification intends, but doing so would add significant complexity to the problem. See latest Desktop Entry Specification.
  4. Execute the command
  5. Immediately exit with the appropriate exit code (so as to not execute multiple Exec lines)

Note, this AWK script addresses a few edge cases that may or may not be properly addressed by some of the other answers. Specifically, this command removes multiple Exec variables (taking care not to otherwise remove the % symbol), will only execute a single Exec line command, and will behave as expected even if the Exec line command contains one or more equals sign (e.g. script.py --profile=name).

Just a few other caveats... According to the specification, TryExec is:

Path to an executable file on disk used to determine if the program is actually installed. If the path is not an absolute path, the file is looked up in the $PATH environment variable. If the file is not present or if it is not executable, the entry may be ignored (not be used in menus, for example).

With that in mind, it doesn't make sense to execute it's value.

Some other concerns are Path and Terminal. Path consists of the working directory to run the program in. Terminal is a boolean that indicates whether the program is run in a terminal window. These can all be addressed, but there's no sense in reinventing the wheel as there are already implementations of the spec. If you do want to implement Path, keep in mind that system() spawns a subprocess, so you can't change working directory by doing something like system("cd \047" working_directory "\047"); system(command). However you could presumably do something like system("cd \047" working_directory "\047 && " command). Note \047 are single quotes (so the command doesn't break on paths with spaces).

The Python Alternative

I'm stealing a page from Carlo here, who suggested creating a Python script to make use of the gi module. Here's a minimal way to execute the same code from the shell without having to create a file and worry about I/O.

launch(){    # Usage: launch PATH [URI...]    python - "$@" <<EOF  import sys  from gi.repository import Gio  Gio.DesktopAppInfo.new_from_filename(sys.argv[1]).launch_uris(sys.argv[2:])  EOF    }  

Then execute the launcher function as follows:

launch ./path/to/shortcut.desktop  

Note the use of URIs is optional. Also, no error checking is performed so you'll want to ensure the launcher exists and is readable (before using it) if you want your script to be durable.


Solution:7

exo-open [[path-to-a-desktop-file]...]  

seems to work in 13.10 release, if exo-utils is installed (like is the case with Xubuntu).


Solution:8

Addendum to Hamish's answer.

Given the deskopen script, you can use a reference to it as the shebang line in a .desktop file, since the comment character is still #. That is to say, put this as the first line of the .desktop file:

#!/usr/bin/env deskopen  

Then flag the .desktop file as executable (e.g. with a chmod +x whatever.desktop), and then you can

path/to/whatever.desktop  

and voilà -- The app will open! (Complete with the icon file I specified, though I have no idea how.)

Now, if you also want deskopen to pass through any command-line parameters, you can instead use this slightly-modified version:

#!/bin/sh  desktop_file=$1  shift  `grep '^Exec' "${desktop_file}" | sed 's/^Exec=//' | sed 's/%.//'` "$@" &  

As an aside, I tried using "#{@:2}" instead of shifting, but it kept giving me 'bad substitution'...


Solution:9

There isn't currently an application that does what you describe in the Ubuntu archives. There are a couple efforts in progress to create a general solution to provide integration for desktop environments (like openbox) that are not compliant with these XDG specifications.

Arch Linux is working on an implementation of xdg-autostart based on the python-xdg libraries. From what I can find, this seems not yet entirely complete, but has some reports of success.

There is also a C++ implementation of xdg-autostart on gitorious (http://gitorious.org/xdg-autostart/) which would likely benefit from wider use.

If either solution works for you, please consider submitting the necessary work for inclusion in either Debian or Ubuntu.

To use either tool with openstart, you would call it in /etc/xdg/openbox/autostart.sh (if I am reading the openbox documentation correctly). If this doesn't work, you can probably call it in any of the openbox session initialisation scripts.


Solution:10

You could use dex.

dex foo.desktop  


Solution:11

I don't have an immediate solution meeting the requirement for "using a standard command", but if you did want to minimally parse the .desktop files or wanted to create a Bash alias, then the following should work:

  • awk -F= '/Exec=/{system($2)}' foo.desktop

another approach that might be interesting, would be to create a kernel-level binfmt-misc method than matches on .desktop files (see grep -r . /proc/sys/fs/binfmt_misc/ for those patterns that you currently have enabled).

At the end of the day, something somewhere will have to parse the .desktop files, it's just a question of how "standard/default" that is.


Solution:12

When trying to test these files I found the simplest way to check that that the DM or session manager would do what I expected was to open the surrounding dir in a UI folder browser and then double-click to open them.

If you are in a command line : gvfs-open . or gnome-open . will open it in the configured folder browser.

The sed thing will not mirror the DM's behaviour, including fiddly stuff like escapes and quoting where you really wouldn't want alternative behaviour. It's not command line, but it did validate things. I also found setting Terminal=true useful for debugging.


Solution:13

This SO answer is what made it clear for me: don't try to execute the desktop file, execute the file pointed to in the desktop file.

For example, execute /home/jsmith/Desktop/x11vnc.sh

Exec=/home/jsmith/Desktop/x11vnc.sh  


Solution:14

Make sure the script your desktop file points to is executable too.

If still doesn't work. Make desktop file runnable in terminal by changing Terminal=true, and put it inside a bash script. Run the script to catch the error output. Change back when errors are corrected.


Solution:15

Hamish's answer is great, but I'd like suggest a simpler alternative, with less piping involved:

$(awk -F= '/^Exec/||/^TryExec/ {print $2;exit}' /usr/share/applications/firefox.desktop)

In this case, awk searches for line starting with Exec, and then we simply print fields after that line, using for loop and = we print field 2, i.e., whatever comes after that field. The curly brackets on the ends of the commands, $(...), are parameter substitution, thus shell will execute whatever awk command returns; in this case, it returns actual command that comes after Exec=.

In some rare cases there may be more than one = sign, which is still a possibility. For that, I suggest

$(awk -F= '/^Exec/||/^TryExec/ {for(i=2;i<=NF;i++) print $i;exit}' /usr/share/applications/firefox.desktop)  


Solution:16

I took the script from Carlo's answer above, and made an attempt to improve on it for my own desktop use.

This version of the script will allow you to run any app as if you entered it on the HUD, so long as it's likely to be the first result. It also lets you pass file arguments for .desktop files that do not support URIs.

#!/usr/bin/env python    from gi.repository import Gio  from argparse import ArgumentParser  import sys, os    def find_app(search_string):      for group in Gio.DesktopAppInfo.search(search_string):          for entry in group:              try:                  return Gio.DesktopAppInfo.new(entry)              except: pass      return None    def main(args):      launcher = None      if os.path.isfile(args.appName[0]):          try:          # If it's a file, do that first.              launcher = Gio.DesktopAppInfo.new_from_filename(args.appName)          except TypeError:              print "'" + args.appName + "' is not a .desktop file"              sys.exit(-1)      # If it's a .desktop file in the DB, try using that      if launcher is None and args.appName.endswith('.desktop'):          try:              launcher = Gio.DesktopAppInfo.new(args.appName)          except TypeError: pass        if launcher is None:          # Search for the app by the text given          launcher = find_app(args.appName)        if launcher is None:          print "No app named " + args.appName + " could be found"          sys.exit(-1)      if (launcher.supports_uris()):          launcher.launch_uris(args.uris, None)      elif (launcher.supports_files()):          launcher.launch(list({ Gio.File.parse_name(x) for x in args.uris }), None)    if __name__ == "__main__":      argParser = ArgumentParser(description="Launch a .desktop file or application")      argParser.add_argument("appName",           help="the name of any application, a desktop file's basename, or a concrete path to a desktop file",           action='store'      )      argParser.add_argument("uris",           nargs='*',           help="Files or URIs to pass to the application"      )      args = argParser.parse_args()      main(args)  

Note:If u also have question or solution just comment us below or mail us on toontricks1994@gmail.com
Previous
Next Post »