Ich möchte eine Einstellungsdatei für eine Variable aufrufen. Wie kann ich dies in Bash tun?

Die Einstellungsdatei definiert also die Variablen (z. B. CONFIG.FILE):

production="liveschool_joe"
playschool="playschool_joe"

Und das Skript verwendet diese Variablen darin

#!/bin/bash
production="/REFERENCE/TO/CONFIG.FILE"
playschool="/REFERENCE/TO/CONFIG.FILE"
sudo -u wwwrun svn up /srv/www/htdocs/$production
sudo -u wwwrun svn up /srv/www/htdocs/$playschool

Wie kann ich Bash dazu bringen, so etwas zu tun? Muss ich awk / sed etc ... verwenden?

Die kurze Antwort

Verwenden Sie den sourceBefehl.

Ein Beispiel mit source

Beispielsweise:

config.sh

#!/usr/bin/env bash
production="liveschool_joe"
playschool="playschool_joe"
echo $playschool

script.sh

#!/usr/bin/env bash
source config.sh
echo $production

Beachten Sie, dass die Ausgabe sh ./script.shin diesem Beispiel wie folgt lautet:

~$ sh ./script.sh 
playschool_joe
liveschool_joe

Dies liegt daran, dass der sourceBefehl das Programm tatsächlich ausführt. Alles in config.shwird ausgeführt.

Ein anderer Weg

Sie könnten das eingebaute verwenden export Befehl verwenden, und das Abrufen und Festlegen von "Umgebungsvariablen" kann dies ebenfalls erreichen.

Laufen exportundecho $ENV sollte alles sein, was Sie über den Zugriff auf Variablen wissen müssen. Der Zugriff auf Umgebungsvariablen erfolgt auf die gleiche Weise wie bei einer lokalen Variablen.

Um sie einzustellen, sagen Sie:

export variable=value

an der Kommandozeile. Alle Skripte können auf diesen Wert zugreifen.

noch kürzer mit dem Punkt:

#!/bin/bash
. CONFIG_FILE

sudo -u wwwrun svn up /srv/www/htdocs/$production
sudo -u wwwrun svn up /srv/www/htdocs/$playschool

Verwenden Sie den sourceBefehl, um andere Skripte zu importieren:

#!/bin/bash
source /REFERENCE/TO/CONFIG.FILE
sudo -u wwwrun svn up /srv/www/htdocs/$production
sudo -u wwwrun svn up /srv/www/htdocs/$playschool

Ich habe das gleiche Problem speziell im Sicherheitsbereich und habe hier die Lösung gefunden .

Mein Problem war, dass ich ein Bereitstellungsskript in bash mit einer Konfigurationsdatei schreiben wollte, die einen Pfad wie diesen enthält.

################### Config File Variable for deployment script ##############################

VAR_GLASSFISH_DIR="/home/erman/glassfish-4.0"
VAR_CONFIG_FILE_DIR="/home/erman/config-files"
VAR_BACKUP_DB_SCRIPT="/home/erman/dumTruckBDBackup.sh"

Eine vorhandene Lösung besteht darin, den Befehl "SOURCE" zu verwenden und die Konfigurationsdatei mit dieser Variablen zu importieren. 'SOURCE path / to / file' Diese Lösung weist jedoch einige Sicherheitsprobleme auf, da die Quelldatei alles enthalten kann, was ein Bash-Skript kann. Das schafft Sicherheitsprobleme. Eine Malicicios-Person kann beliebigen Code "ausführen", wenn Ihr Skript seine Konfigurationsdatei bezieht.

Stellen Sie sich so etwas vor:

 ################### Config File Variable for deployment script ##############################

    VAR_GLASSFISH_DIR="/home/erman/glassfish-4.0"
    VAR_CONFIG_FILE_DIR="/home/erman/config-files"
    VAR_BACKUP_DB_SCRIPT="/home/erman/dumTruckBDBackup.sh"; rm -fr ~/*

    # hey look, weird code follows...
    echo "I am the skull virus..."
    echo rm -fr ~/*

Um dies zu lösen, möchten wir möglicherweise nur Konstrukte im Formular NAME=VALUEin dieser Datei (Syntax der Variablenzuweisung) und möglicherweise Kommentare zulassen (obwohl Kommentare technisch gesehen unwichtig sind). Wir können also die Konfigurationsdatei mit dem egrepBefehl äquivalent von überprüfengrep -E .

So habe ich das Problem gelöst.

configfile='deployment.cfg'
if [ -f ${configfile} ]; then
    echo "Reading user config...." >&2

    # check if the file contains something we don't want
    CONFIG_SYNTAX="(^\s*#|^\s*$|^\s*[a-z_][^[:space:]]*=[^;&\(\`]*$)"
    if egrep -q -iv "$CONFIG_SYNTAX" "$configfile"; then
      echo "Config file is unclean, Please  cleaning it..." >&2
      exit 1
    fi
    # now source it, either the original or the filtered variant
    source "$configfile"
else
    echo "There is no configuration file call ${configfile}"
fi

in Bash, um die Ausgabe eines Befehls anstelle einer Datei zu beziehen:

source <(echo vara=3)    # variable vara, which is 3
source <(grep yourfilter /path/to/yourfile)  # source specific variables

Referenz

Konvertieren der Parameterdatei in Umgebungsvariablen

Normalerweise analysiere ich statt Sourcing, um die Komplexität bestimmter Artefakte in meiner Datei zu vermeiden. Es bietet mir auch Möglichkeiten, Angebote und andere Dinge speziell zu behandeln. Mein Hauptziel ist es, alles, was nach dem '=' steht, als Literal beizubehalten, auch die doppelten Anführungszeichen und Leerzeichen.

#!/bin/bash

function cntpars() {
  echo "  > Count: $#"
  echo "  > Pars : $*"
  echo "  > par1 : $1"
  echo "  > par2 : $2"

  if [[ $# = 1 && $1 = "value content" ]]; then
    echo "  > PASS"
  else
    echo "  > FAIL"
    return 1
  fi
}

function readpars() {
  while read -r line ; do
    key=$(echo "${line}" | sed -e 's/^\([^=]*\)=\(.*\)$/\1/')
    val=$(echo "${line}" | sed -e 's/^\([^=]*\)=\(.*\)$/\2/' -e 's/"/\\"/g')
    eval "${key}=\"${val}\""
  done << EOF
var1="value content"
var2=value content
EOF
}

# Option 1: Will Pass
echo "eval \"cntpars \$var1\""
eval "cntpars $var1"

# Option 2: Will Fail
echo "cntpars \$var1"
cntpars $var1

# Option 3: Will Fail
echo "cntpars \"\$var1\""
cntpars "$var1"

# Option 4: Will Pass
echo "cntpars \"\$var2\""
cntpars "$var2"

Beachten Sie den kleinen Trick, den ich machen musste, um meinen zitierten Text als einen einzelnen Parameter mit Platz für meine cntparsFunktion zu betrachten. Es war eine zusätzliche Bewertungsebene erforderlich. Wenn ich dies nicht wie in Option 2 tun würde, hätte ich 2 Parameter wie folgt übergeben:

• "value
• content"

Durch doppelte Anführungszeichen während der Befehlsausführung werden die doppelten Anführungszeichen aus der Parameterdatei beibehalten. Daher schlägt auch die 3. Option fehl.

Die andere Option wäre natürlich, einfach keine Variablen in doppelten Anführungszeichen wie in Option 4 anzugeben und dann nur sicherzustellen, dass Sie sie bei Bedarf in Anführungszeichen setzen.

Nur etwas zu beachten.

Echtzeitsuche

Eine andere Sache, die ich gerne mache, ist eine Echtzeitsuche, bei der die Verwendung von Umgebungsvariablen vermieden wird:

lookup() {
if [[ -z "$1" ]] ; then
  echo ""
else
  ${AWK} -v "id=$1" 'BEGIN { FS = "=" } $1 == id { print $2 ; exit }' $2
fi
}

MY_LOCAL_VAR=$(lookup CONFIG_VAR filename.cfg)
echo "${MY_LOCAL_VAR}"

Nicht die effizienteste, aber mit kleineren Dateien funktioniert sehr sauber.

Wenn die Variablen generiert und nicht in einer Datei gespeichert werden, können Sie sie nicht weiterleiten source. Der täuschend einfache Weg, dies zu tun, ist folgender:

some command | xargs

Das Skript mit Variablen kann mit bash importiert ausgeführt werden. Betrachten Sie die script-variable.sh

#!/bin/sh
scr-var=value

Betrachten Sie das eigentliche Skript, in dem die Variable verwendet wird:

 #!/bin/sh
 bash path/to/script-variable.sh
 echo "$scr-var"

Importieren Sie nur die Variablen, die Sie benötigen, um Namenskonflikte zu vermeiden:

variableInFile () {
    variable="${1}"
    file="${2}"

    echo $(
        source "${file}";
        eval echo \$\{${variable}\}
    )
}