Creazione di file eseguibili su Linux

Question

Una cosa che ho intenzione di fare è scrivere (dolorosamente semplice) script Perl, e mi piacerebbe essere in grado di eseguirli senza chiamare esplicitamente Perl dal terminale. Apprezzo che, per fare questo, ho bisogno di concedere loro i permessi di esecuzione. Fare questo con chmod è abbastanza facile, ma sembra anche un passo extra leggermente laborioso. Quello che vorrei è una delle due cose:

In primo luogo, c'è un modo per impostare il flag di esecuzione quando si salva un file? Attualmente sto sperimentando gedit e geany, ma sarei disposto a passare ad un editor simile (o meglio) se avesse questa capacità.

In caso contrario, esiste un modo per dichiarare che tutti i file creati in una particolare directory devono avere autorizzazioni di esecuzione?

Il mio umask è impostato su 022, che dovrebbe essere OK, per quanto ho capito, ma sembrerebbe che i file vengono creati come file di testo (con 666 autorizzazioni predefinite) anziché file eseguibili (con 777 autorizzazioni predefinite) .

Forse sono solo pigro, ma immagino che ci sia un modo più conveniente di cercare ogni singolo copione che si crea.

Answer 1

Non è davvero un grosso problema. Si può solo fare uno script con il singolo comando:

chmod a+x *.pl 

ed eseguire lo script dopo aver creato un file di perl. In alternativa, si potrebbe aprire un file con un comando come questo:

touch filename.pl && chmod a+x filename.pl && vi filename.pl # choose your favorite editor 

Answer 2

Marchio file eseguibile:

chmod + x il file

trovare la posizione di Perl:

quale perl

Ciò dovrebbe restituire qualcosa come

/bin/perl volte/usr/local/bin

Poi nella prima riga dello script aggiunge: percorso

# "! "/ perl con percorso dall'alto, ad es

#!/Bin/perl

Quindi è possibile eseguire il file

./file

Ci possono essere alcuni problemi con il PATH, quindi si consiglia per cambiare anche questo ...

Answer 3

Quello che descrivi è il modo corretto di gestirlo.

Hai detto che vuoi rimanere nella GUI. Di solito è possibile impostare il bit di esecuzione tramite il menu delle proprietà del file. Potresti anche imparare come creare un'azione personalizzata per il menu di scelta rapida per farlo per te se sei così inclinato. Ciò dipende ovviamente dall'ambiente desktop.

Se si utilizza un editor più avanzato, è possibile creare script l'azione che accada quando il file viene salvato. Ad esempio (ho familiarità con Vim), puoi aggiungere questo al tuo .vimrc per creare qualsiasi nuovo file che inizi con "#!/*/bin/*" eseguibile.

au BufWritePost * if getline(1) =~ "^#!" | if getline(1) =~ "/bin/" | silent !chmod +x <afile> | endif | endif 

Answer 4

Credo che il problema si sta eseguendo in è che, anche se è possibile impostare i propri valori di umask nel sistema, questo non consente di controllare in modo esplicito le autorizzazioni predefinite impostate su un nuovo file da gedit (o qualsiasi editor che usi).

Credo che questo dettaglio è hard-coded in gedit e la maggior parte degli altri redattori. Le opzioni per modificarlo sono (a) l'hacking della tua mod di gedit o (b) la ricerca di un editor di testo che ti permetta di impostare una preferenza per i permessi di default sui nuovi file. (Scusate, non conosco nessuno.)

Alla luce di ciò, non è poi così male avere a chmod i file, giusto?

Answer 5

Non è necessario modificare l'editor o cambiare editor.

Invece possiamo creare uno script per guardare le directory di sviluppo e i file chmod man mano che vengono creati. Questo è ciò che ho fatto nello script di bash allegato. Probabilmente vorrai leggere i commenti e modificare la sezione "config" in base alle tue esigenze, quindi ti suggerirei di inserirla nella tua directory $ HOME/bin/e aggiungerne l'esecuzione al tuo $ HOME/.login o file simile. O puoi semplicemente eseguirlo dal terminale.

Questo script richiede inotifywait, che viene fornito nel pacchetto inotify-tools su Ubuntu,

sudo apt-get install inotify-tools 

Suggerimenti/modifiche/migliorie sono i benvenuti.

#!/usr/bin/env bash 

# --- usage --- # 
# Depends: 'inotifywait' available in inotify-tools on Ubuntu 
# 
# Edit the 'config' section below to reflect your working directory, WORK_DIR, 
# and your watched directories, WATCH_DIR. Each directory in WATCH_DIR will 
# be logged by inotify and this script will 'chmod +x' any new files created 
# therein. If SUBDIRS is 'TRUE' this script will watch WATCH_DIRS recursively. 
# I recommend adding this script to your $HOME/.login or similar to have it 
# run whenever you log into a shell, eg 'echo "watchdirs.sh &" >> ~/.login'. 
# This script will only allow one instance of itself to run at a time. 

# --- config --- # 

WORK_DIR="$HOME/path/to/devel" # top working directory (for cleanliness?) 
WATCH_DIRS=" \ 
    $WORK_DIR/dirA \ 
    $WORK_DIR/dirC \ 
    "       # list of directories to watch 
SUBDIRS="TRUE"     # watch subdirectories too 
NOTIFY_ARGS="-e create -q"  # watch for create events, non-verbose 


# --- script starts here --- # 
# probably don't need to edit beyond this point 

# kill all previous instances of myself 
SCRIPT="bash.*`basename $0`" 
MATCHES=`ps ax | egrep $SCRIPT | grep -v grep | awk '{print $1}' | grep -v $$` 
kill $MATCHES >& /dev/null 

# set recursive notifications (for subdirectories) 
if [ "$SUBDIRS" = "TRUE" ] ; then 
    RECURSE="-r" 
else 
    RECURSE="" 
fi 

while true ; do 
    # grab an event 
    EVENT=`inotifywait $RECURSE $NOTIFY_ARGS $WATCH_DIRS` 

    # parse the event into DIR, TAGS, FILE 
    OLDIFS=$IFS ; IFS=" " ; set -- $EVENT 
    E_DIR=$1 
    E_TAGS=$2 
    E_FILE=$3 
    IFS=$OLDIFS 

    # skip if it's not a file event or already executable (unlikely) 
    if [ ! -f "$E_DIR$E_FILE" ] || [ -x "$E_DIR$E_FILE" ] ; then 
     continue 
    fi 

    # set file executable 
    chmod +x $E_DIR$E_FILE 
done