.xinitrc vs. programas AwesomeWM Autorun. Qual deles é melhor?

Question

Eu tenho procurado uma maneira de iniciar alguns aplicativos personalizados quando eu fizer login na minha sessão no LightDM. Até agora, encontrei duas maneiras diferentes:

1. Personalizar .xinitrc: Por exemplo, se eu quiser adicionar uma janela de terminal sempre que eu iniciar o servidor X, só precisarei adicionar xterm -geometry 80x50+494+51 & antes de exec awesome .

2. Adicione alguns aplicativos ao rc.lua: como visto aqui , os aplicativos começam quando o AwesomeWM inicia .

Os métodos são claros, mas eu encontrei um problema que me fez pensar em qual opção seria melhor.

A primeira maneira só funcionaria se eu explicitamente digitar startx em um TTY. Iniciar o servidor X sem esse comando (por exemplo, ligar o computador normalmente) não iniciará os aplicativos. Então, como eu poderia evitar que isso acontecesse?

A questão principal aqui, no entanto, é: no caso de eu poder fazer .xinitrc funcionar, seria uma maneira "melhor" (em termos de eficiência e especialmente segurança) para prosseguir do que editar minha própria cópia de rc.lua ?

    

Answer 1

Eu acredito que os programas autorun AwesomeWM são melhores quando bem feitos

Why = Se você sair de um dos seus programas de execução automática * sempre e quiser reiniciá-los você (a) reinicializa o X [fechando tudo no processo], (b) os reinicia a partir de um shell [mensagens de saída agora shell], (c) criar código especial de re-lançamento em rc.lua [no topo do código de lançamento que você colocar em .xinitrc

Como = Isso funciona bem para mim ... a) Assim que as linhas de depuração do rc.lua forem adicionadas ...

    local gears         = { table   = require( "gears.table" )          ,
                            p_call  = require( "gears.protected_call" ) }

    gears.p_call( dofile, path_this .. "runonce.lua" )

b) E aqui está a parte "when done well" (IMHO) que está em runonce.lua ...

    local naughty   = require( "naughty" )
    local awful     = { spawn = require( "awful.spawn" ) }
    local string    = { sub = string.sub        ,
                        find = string.find      ,
                        format = string.format  }

    -- This function makes sure the application is not restarted when awesome is reloaded
    local function run_once( command )
        local args_start = string.find( command, " " )
        local pgrep_name = args_start and command:sub( 0, args_start - 1 ) or command

        local command = "pgrep -u $USER -x " .. pgrep_name .. " > /dev/null || (" .. command .. ")"

        awful.spawn.easy_async_with_shell(
            command,
            function( stdout, stderr, exitreason, exitcode )
                if exitcode ~= 0 then
                    naughty.notify({
                        preset  = naughty.config.presets.critical           ,
                        text    = string.format(    "%s\n\n%s\n%s\n%s\n%s", 
                                                    command,
                                                    stdout,
                                                    stderr,
                                                    exitreason,
                                                    exitcode )              })
                end
            end )
    end

    -- Start these if not already running
    run_once( "guake &> /dev/null" )
    run_once( "remmina -i &> /dev/null" )
    run_once( "skypeforlinux" )

Por que acredito que é bem feito ...

1) Trabalha com programas que possuem parâmetros [procura somente pelo nome, não pelos argumentos] 2) Tem um alerta se as coisas derem errado [sem matar Awesome] 3) Edite somente a seção inferior

Finalmente ... mod + ctrl + r reloads awesome [nada realmente muda, apenas redefine memmory] e, claro, os aplicativos que você sempre quer são relançados exatamente da mesma maneira que eram na primeira vez

    

Answer 2

Atualização 2018:

Usar o início automático do XDG ainda é a maneira padrão de fazer isso. No entanto, o Awesome v4.3 adiciona uma nova função awful.spawn.once que se encarrega de salvar aplicação "single instance" propriedade diretamente no servidor X. Isso permite que spawn seja chamado de tempo múltiplo enquanto é executado apenas uma vez. Funciona através do reinício.

Original:

O melhor é implementar o protocolo de início automático do XDG. Geralmente é sobre adicionar arquivos ao ~/.config/autostart , então ter um script ou um daemon cuida de iniciar os aplicativos. Este script ou daemon é iniciado pelo gerenciador de sessões ou pelo .xinitrc .

rc.lua não deve ser usado para o Autostart, pois ele pode ser reiniciado em tempo aleatório ( mod4+ctrl+r ) e re-executar tudo. Alguns usuários têm sistemas elaborados para detectar se algo já foi lançado, mas na minha opinião não vale a pena.

A segunda melhor maneira é diretamente de .xinitrc .

    

Answer 3

Eu tenho um script muito simples chamado /usr/local/bin/awesome_run_once :

#!/bin/bash

pgrep $@ > /dev/null || ($@ &)

No final do meu ~/.config/awesome/rc.lua , adiciono algumas chamadas a ele com o aplicativo que quero executar:

-- auto start programs
awful.util.spawn("awesome_run_once wicd-client")
awful.util.spawn("awesome_run_once redshift")
awful.util.spawn("awesome_run_once nextcloud")

Funciona bem o suficiente.

Eu tenho essa ideia de Autostart - awesome mas a página não parece mais estar online ...