Por lo que puedo reunir, los .desktoparchivos son accesos directos que permiten personalizar la configuración de la aplicación. Por ejemplo, tengo muchos de ellos en mi /usr/share/applications/carpeta.

Si abro esa carpeta nautilus, puedo ejecutar estas aplicaciones simplemente haciendo doble clic en su archivo asociado, por ejemplo, al hacer doble clic se firefox.desktopejecuta Firefox. Sin embargo, no puedo encontrar una manera de hacer lo mismo a través de la terminal.

Si lo hago gnome-open foo.desktop, simplemente se abre foo.desktopcomo un archivo de texto. Si lo hago ejecutable y luego lo ejecuto en bash, simplemente falla (lo que se espera, claramente no es un script de bash).
EDITAR: Hacer exec /fullpath/foo.desktopme da un Permission deniedmensaje, incluso si cambio de propietario. Si hago ejecutable y hago el mismo comando, la pestaña de terminal que estoy usando simplemente se cierra (supongo que se bloquea). Finalmente, si lo hago sudo exec /fullpath/foo.desktop, recibo un informe de error sudo: exec: command not found.

Esa es mi pregunta, ¿cómo puedo ejecutar un foo.desktoparchivo desde la terminal?

El comando que se ejecuta está contenido dentro del archivo de escritorio, precedido por Exec=lo que puede extraer y ejecutar:

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

Para romper eso

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

Podría poner esto en un archivo, digamos ~/bin/deskopencon el contenido

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

Luego hazlo ejecutable

chmod +x ~/bin/deskopen

Y luego podrías hacer, por ejemplo

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

Los argumentos ( %u, %Fetc.) se detallan en http://standards.freedesktop.org/desktop-entry-spec/desktop-entry-spec-1.0.html#exec-variables ; ninguno de ellos es relevante para el lanzamiento en la línea de comandos .

La respuesta debería ser

xdg-open program_name.desktop

Pero debido a un error, esto ya no funciona.

Con cualquier ubuntu reciente que admita gtk-launchsimplemente simplemente vaya

gtk-launch <file>donde está el nombre del archivo .desktop con o sin la .desktopparte

Así se gtk-launch fooabrefoo.desktop

( gtk-launchdocumentación )

El .desktop debe estar en / usr / share / aplicaciones, / usr / local / share / aplicaciones o ~ / .local / share / aplicaciones

Utilizable desde la terminal o alt + F2 (alt + F2 almacena el comando en el historial de manera tan accesible)

A partir de hoy (12.10) el error aún está presente. De hecho, depende de cómo funciona gvfs-open(llamado por xdg-open).

Aún así, logré una solución rápida (robando inspiración del código fuente nautilus). Es un poco complicado, pero funciona perfectamente en Ubuntu 12.10, agregando un ícono significativo (no más ?) en el iniciador de Unity.

Primero, escribí un script de Python usando Gio y lo guardé como ~/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)

El script necesita tener el permiso ejecutable, así que ejecuté esto en una terminal:

chmod +x ~/bin/run-desktop

Luego creé la .desktopentrada relativa en ~/.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

Finalmente, asocié la entrada como el controlador predeterminado en ~/.local/share/applications/mimeapps.listla [Default Applications]sección como:

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

Ahora:

• xdg-open something.desktop funciona como se esperaba
• #!/usr/bin/xdg-open el hashbang en la parte superior de una entrada de escritorio ejecutable también funciona

Será un trabajo inútil gvfs-openresolver el error, pero mientras tanto ...

La direccion correcta

Realmente deberías estar usando gtk-launchsi está disponible. Por lo general, forma parte del paquete libgtk-3-bin (esto puede variar según la distribución).

gtk-launch se usa de la siguiente manera:

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

Tenga en cuenta que gtk-launchrequiere la instalación del archivo .desktop (es decir, ubicado en /usr/share/applicationso ~/.local/share/applications).

Por lo tanto, para evitar esto, podemos usar una pequeña función de Bash que instala temporalmente el archivo .desktop deseado antes de iniciarlo. La forma "correcta" de instalar un archivo .desktop es a través de, desktop-file-installpero voy a ignorar eso.

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

    )

}

Puede usarlo así (y también pasar argumentos adicionales o URI si lo desea):

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

La alternativa manual

Si desea analizar y ejecutar manualmente un archivo .desktop , puede hacerlo con el siguiente awkcomando:

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

Si desea tratar el awkcomando como un script todo en uno; incluso podemos mostrar un mensaje de error y salir con un código de retorno de 1 en caso de que no se encuentre un comando Exec :

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}}'

Los comandos mencionados anteriormente:

1. Encuentra la línea que comienza con Exec =
2. Eliminar Exec =
3. Elimine cualquier variable Exec (p %f. Ej . %u, %U). Es posible reemplazarlos con argumentos posicionales según lo previsto en la especificación, pero hacerlo agregaría una complejidad significativa al problema. Consulte la última especificación de entrada de escritorio .
4. Ejecutar el comando
5. Salga inmediatamente con el código de salida apropiado (para no ejecutar varias líneas Exec )

Tenga en cuenta que este script de AWK aborda algunos casos extremos que pueden o no ser abordados adecuadamente por algunas de las otras respuestas. Específicamente, este comando elimina múltiples variables Exec (teniendo cuidado de no eliminar el símbolo%), solo ejecutará un solo comando de línea Exec y se comportará como se esperaba incluso si el comando de línea Exec contiene uno o más signos de igual (por ejemplo script.py --profile=name).

Solo algunas otras advertencias ... De acuerdo con la especificación, TryExec es:

Ruta a un archivo ejecutable en el disco utilizado para determinar si el programa está realmente instalado. Si la ruta no es absoluta, el archivo se busca en la variable de entorno $ PATH. Si el archivo no está presente o si no es ejecutable, la entrada puede ignorarse (por ejemplo, no se puede usar en los menús).

Con eso en mente, no tiene sentido ejecutar su valor.

Algunas otras preocupaciones son Path y Terminal . La ruta consiste en el directorio de trabajo para ejecutar el programa. Terminal es un booleano que indica si el programa se ejecuta en una ventana de terminal. Todos estos pueden abordarse, pero no tiene sentido reinventar la rueda ya que ya hay implementaciones de la especificación. Si desea implementar Path , tenga en cuenta que system()genera un subproceso, por lo que no puede cambiar el directorio de trabajo haciendo algo como system("cd \047" working_directory "\047"); system(command). Sin embargo, presumiblemente podrías hacer algo así system("cd \047" working_directory "\047 && " command). Nota \ 047 son comillas simples (por lo que el comando no se rompe en las rutas con espacios).

La alternativa a Python

Aquí estoy robando una página de Carlo , quien sugirió crear un script de Python para usar el módulo gi . Aquí hay una forma mínima de ejecutar el mismo código desde el shell sin tener que crear un archivo y preocuparse por las E / S.

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

}

Luego ejecute la función del iniciador de la siguiente manera:

launch ./path/to/shortcut.desktop

Tenga en cuenta que el uso de URI es opcional. Además, no se realiza ninguna comprobación de errores, por lo que querrá asegurarse de que el iniciador exista y sea legible (antes de usarlo) si desea que su script sea duradero.

Si bien OP no estaba preguntando sobre KDE, para cualquiera que esté ejecutando KDE se puede usar el siguiente comando:

kioclient exec <path-to-desktop-file>

En Fedora, esto está incluido en las kde-runtimerpm.

Podrías usar dex .

dex foo.desktop

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

parece funcionar en la versión 13.10, si está instalado exo-utils (como es el caso de Xubuntu).

Adición a la respuesta de Hamish.

Dado el script deskopen, puede usar una referencia a él como la línea shebang en un archivo .desktop , ya que el carácter de comentario todavía está #. Es decir, ponga esto como la primera línea del archivo .desktop :

#!/usr/bin/env deskopen

Luego marque el archivo .desktop como ejecutable (por ejemplo, con a chmod +x whatever.desktop), y luego puede

path/to/whatever.desktop

y voilà - ¡La aplicación se abrirá! (Complete con el archivo de icono que especifiqué, aunque no tengo idea de cómo hacerlo).

Ahora, si también desea que deskopen pase por los parámetros de la línea de comandos, puede usar esta versión ligeramente modificada:

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

Como comentario aparte, intenté usar en "#{@:2}"lugar de shifting, pero seguía dándome una 'mala sustitución' ...

Actualmente no hay una aplicación que haga lo que usted describe en los archivos de Ubuntu. Hay un par de esfuerzos en progreso para crear una solución general para proporcionar integración para entornos de escritorio (como openbox) que no cumplen con estas especificaciones XDG.

Arch Linux está trabajando en una implementación de xdg-autostart basada en las bibliotecas python-xdg. Por lo que puedo encontrar, esto aún no parece completamente completo, pero tiene algunos informes de éxito.

También hay una implementación en C ++ de xdg-autostart en gitorious (http://gitorious.org/xdg-autostart/) que probablemente se beneficiaría de un uso más amplio.

Si alguna de las soluciones funciona para usted, considere enviar el trabajo necesario para su inclusión en Debian o Ubuntu.

Para usar cualquiera de las herramientas con openstart, debe llamarlo en /etc/xdg/openbox/autostart.sh (si estoy leyendo la documentación de openbox correctamente). Si esto no funciona, probablemente pueda llamarlo en cualquiera de los scripts de inicialización de sesión de openbox.

No tengo una solución inmediata que cumpla con el requisito de "usar un comando estándar" , pero si desea analizar mínimamente los .desktoparchivos o desea crear un alias Bash, entonces lo siguiente debería funcionar:

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

Otro enfoque que podría ser interesante sería crear un binfmt-miscmétodo a nivel de kernel que coincida con los .desktoparchivos (consulte grep -r . /proc/sys/fs/binfmt_misc/los patrones que ha habilitado actualmente).

Al final del día, algo en algún lugar tendrá que analizar los .desktoparchivos, es solo una cuestión de qué tan "estándar / predeterminado" es.

Tomé el guión de la respuesta de Carlo anterior e intenté mejorarlo para mi propio uso en el escritorio.

Esta versión del script le permitirá ejecutar cualquier aplicación como si la hubiera ingresado en el HUD, siempre que sea el primer resultado. También le permite pasar argumentos de archivo para archivos .desktop que no admiten URI.

#!/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):
        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)
    else :
        launcher.launch()

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)

Al intentar probar estos archivos, encontré la forma más simple de verificar que el DM o el administrador de la sesión hicieran lo que esperaba era abrir el directorio circundante en un navegador de carpetas de la interfaz de usuario y luego hacer doble clic para abrirlos.

Si está en una línea de comando: gvfs-open .o la gnome-open .abrirá en el explorador de carpetas configurado.

Lo sed no reflejará el comportamiento del DM, incluidas cosas complicadas como escapes y citas donde realmente no querría un comportamiento alternativo. No es la línea de comando, pero sí validado las cosas. También encontré la configuración Terminal=trueútil para la depuración.

Esta respuesta SO es lo que me dejó claro: no intente ejecutar el archivo de escritorio, ejecute el archivo señalado en el archivo de escritorio.

Por ejemplo, ejecute /home/jsmith/Desktop/x11vnc.sh

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

(Compilado de las otras respuestas aquí)

Dependiendo de su sistema y los diversos errores que pueden existir o no en su sistema, intente lo siguiente hasta que uno de ellos funcione:

1. xdg-open program_name.desktop
2. exo-open program_name.desktop
3. gtk-launch program_name.desktop
4. kioclient exec program_name.desktop
5. dex program_name.desktop

Tenga en cuenta que en los sistemas Ubuntu, sus lanzadores de escritorio "menú de inicio" están disponibles en /usr/share/applications/.

Como ejemplo, para mostrar cuál de los comandos anteriores funciona o no en mi sistema Ubuntu 14.04, estos son los resultados de las siguientes llamadas:

1. xdg-open /usr/share/applications/eclipse_for_cpp.desktop # Falla debido a un error (intenta que guarde este archivo .desktop)
2. exo-open /usr/share/applications/eclipse_for_cpp.desktop # Trabajos
3. gtk-launch /usr/share/applications/eclipse_for_cpp.desktop # Falla con "gtk-launch: no existe tal aplicación"
4. kioclient exec /usr/share/applications/eclipse_for_cpp.desktop # Trabajos
5. dex /usr/share/applications/eclipse_for_cpp.desktop# Falla, y sudo apt install dexno puede localizar el paquete dex

Asegúrese de que el script al que apunta su archivo de escritorio también sea ejecutable.

Si aún no funciona. Haga que el archivo de escritorio pueda ejecutarse en la terminal cambiando Terminal=truey colóquelo dentro de un script bash. Ejecute el script para atrapar la salida del error. Cambiar de nuevo cuando se corrijan los errores.

La respuesta de Hamish es excelente, pero me gustaría sugerir una alternativa más simple, con menos tuberías involucradas:

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

En este caso, awkbusca una línea que comience por Exec, y luego simplemente imprimimos los campos después de esa línea, usando for loop e =imprimimos el campo 2, es decir, lo que venga después de ese campo. Los corchetes en los extremos de los comandos $(...)son sustitución de parámetros, por lo tanto, shell ejecutará lo que devuelva el comando awk; en este caso, devuelve el comando real que viene después Exec=.

En algunos casos raros, puede haber más de un =signo, que todavía es una posibilidad. Por eso, sugiero

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