Il modo migliore per leggere un file di configurazione in bash

Qual è il modo migliore per leggere un file di configurazione in bash?
Ad esempio, hai uno script e non sei disposto a compilare manualmente tutte le configurazioni ogni volta che chiami lo script.

Modifica 1: Penso di non averlo chiarito, quindi: quello che voglio è ... Ho un configfile che è come

variable_name value  
variable_name value ...  

e voglio leggerlo. So che potrei semplicemente accettarlo per gli argomenti che sto cercando o così ... ma forse c'è un modo più intelligente :)

Come diceva mbiber, sourceun altro file. Ad esempio, il tuo file di configurazione (diciamo some.config) sarebbe:

var1=val1
var2=val2

E la tua sceneggiatura potrebbe apparire come:

#! /bin/bash

# Optionally, set default values
# var1="default value for var1"
# var1="default value for var2"

. /path/to/some.config

echo "$var1" "$var2"

I molti file in /etc/defaultgenere servono come file di configurazione per altri script di shell in modo simile. Un esempio molto comune dai post qui è /etc/default/grub. Questo file viene utilizzato per impostare le opzioni di configurazione per GRUB, poiché grub-mkconfigè uno script shell che lo genera:

sysconfdir="/etc"
#…
if test -f ${sysconfdir}/default/grub ; then
  . ${sysconfdir}/default/grub
fi

Se devi veramente elaborare la configurazione del modulo:

var1 some value 1
var2 some value 2

Quindi potresti fare qualcosa del tipo:

while read var value
do
    export "$var"="$value"
done < /path/to/some.config

(Potresti anche fare qualcosa del genere eval "$var=$value", ma è più rischioso rispetto all'approvvigionamento di uno script. Inavvertitamente potresti interromperlo più facilmente di un file di origine.)

Ovviamente, non sono lo bashspecialista qui, ma il concetto non dovrebbe essere diverso in qualsiasi lingua tu usi:

Un esempio

Nell'esempio seguente, è possibile utilizzare uno script (molto) di base per impostare una stringa o stampare una stringa, come impostato nel file di configurazione:

#!/bin/bash

# argument to set a new string or print the set string
arg=$1
# possible string as second argument
string=$2
# path to your config file
configfile="$HOME/stringfile"

# if the argument is: "set", write the string (second argument) to a file
if [ "$arg" == "set" ]
then
echo "$string" > $configfile 
# if the argunment is "print": print out the set string, as defined in your file
elif [ "$arg" == "print" ]
then 
echo "$( cat $configfile )"
fi

Poi

• Per impostare una stringa nel file di configurazione:

  $ '/home/jacob/Bureaublad/test.sh' set "Een aap op een fiets, hoe vind je zoiets?"

• Successivamente, per stampare la stringa, come definita nel "file di configurazione":

  $ '/home/jacob/Bureaublad/test.sh' print
  Een aap op een fiets, hoe vind je zoiets?

Naturalmente, in un vero script applicato, devi aggiungere molte cose per assicurarti che gli argomenti siano corretti, decidere cosa fare quando l'input è errato, il file delle impostazioni non esiste ecc., Ma:

Questa è l'idea di base

Utilizzare sourceo .per caricare un file.

source /path/to/file

o

. /path/to/file

Si consiglia inoltre di verificare se il file esiste prima di caricarlo perché non si desidera continuare a eseguire lo script se non è presente un file di configurazione.

Sto usando questo ...

#!/bin/bash

CFG_FILE=/etc/test.conf
CFG_CONTENT=$(cat $CFG_FILE | sed -r '/[^=]+=[^=]+/!d' | sed -r 's/\s+=\s/=/g')
eval "$CFG_CONTENT"

Il file conf viene analizzato con sed e quindi valutato come semplici assegnazioni variabili

Prima sed analisi dei valori chiave (supporta anche = circondato da spazi)

Il secondo sed rimuove gli spazi intorno a = segno per un'assegnazione variabile valida

È possibile aggiungere un ulteriore trattamento sed

Tutti gli altri testi non corrispondenti nel file conf verranno rimossi (inclusi # o; commento e altro)

Essere consapevoli del fatto che i comandi di shell a linea singola possono anche essere valutati da questo file di configurazione!

#------------------------------------------------------------------------------
# parse the ini like $0.$host_name.cnf and set the variables
# cleans the unneeded during after run-time stuff. Note the MainSection
# courtesy of : http://mark.aufflick.com/blog/2007/11/08/parsing-ini-files-with-sed
#------------------------------------------------------------------------------
doParseConfFile(){
    # set a default cnfiguration file
    cnf_file="$run_unit_bash_dir/$run_unit.cnf"

    # however if there is a host dependant cnf file override it
    test -f "$run_unit_bash_dir/$run_unit.$host_name.cnf" \
    && cnf_file="$run_unit_bash_dir/$run_unit.$host_name.cnf"

    # yet finally override if passed as argument to this function
    # if the the ini file is not passed define the default host independant ini file
    test -z "$1" || cnf_file=$1;shift 1;


    test -z "$2" || ini_section=$2;shift 1;
    doLog "DEBUG read configuration file : $cnf_file"
    doLog "INFO read [$ini_section] section from config file"

    # debug echo "@doParseConfFile cnf_file:: $cnf_file"
    # coud be later on parametrized ...
    test -z "$ini_section" && ini_section='MAIN_SETTINGS'

    doLog "DEBUG reading: the following configuration file"
    doLog "DEBUG ""$cnf_file"
    ( set -o posix ; set ) | sort >"$tmp_dir/vars.before"

    eval `sed -e 's/[[:space:]]*\=[[:space:]]*/=/g' \
        -e 's/#.*$//' \
        -e 's/[[:space:]]*$//' \
        -e 's/^[[:space:]]*//' \
        -e "s/^\(.*\)=\([^\"']*\)$/\1=\"\2\"/" \
        < $cnf_file \
        | sed -n -e "/^\[$ini_section\]/,/^\s*\[/{/^[^#].*\=.*/p;}"`

    ( set -o posix ; set ) | sort >"$tmp_dir/vars.after"

    doLog "INFO added the following vars from section: [$ini_section]"
    cmd="$(comm -3 $tmp_dir/vars.before $tmp_dir/vars.after | perl -ne 's#\s+##g;print "\n $_ "' )"
    echo -e "$cmd"
    echo -e "$cmd" >> $log_file
    echo -e "\n\n"
    sleep 1; printf "\033[2J";printf "\033[0;0H" # and clear the screen
}
#eof func doParseConfFile