Je veux appeler un fichier de paramètres pour une variable, comment puis-je faire cela dans bash?

Ainsi, le fichier de paramètres définira les variables (par exemple: CONFIG.FILE):

production="liveschool_joe"
playschool="playschool_joe"

Et le script utilisera ces variables dedans

#!/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

Comment puis-je faire en sorte que Bash fasse quelque chose comme ça? Dois-je utiliser awk / sed etc ...?

La réponse courte

Utilisez la sourcecommande.

Un exemple utilisant source

Par exemple:

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

Notez que la sortie de sh ./script.shcet exemple est:

~$ sh ./script.sh 
playschool_joe
liveschool_joe

C'est parce que la sourcecommande exécute réellement le programme. Tout config.shest exécuté.

Autrement

Vous pouvez utiliser la exportcommande intégrée et obtenir et définir des "variables d'environnement" peuvent également accomplir cela.

Exécuter exportet echo $ENVdevrait être tout ce que vous devez savoir sur l'accès aux variables. L'accès aux variables d'environnement se fait de la même manière qu'une variable locale.

Pour les définir, dites:

export variable=value

sur la ligne de commande. Tous les scripts pourront accéder à cette valeur.

encore plus court en utilisant le point:

#!/bin/bash
. CONFIG_FILE

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

Utilisez la sourcecommande pour importer d'autres scripts:

#!/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

J'ai le même problème spécialement en cas de sécurité et j'ai trouvé la solution ici .

Mon problème était que je voulais écrire un script de déploiement en bash avec un fichier de configuration contenant un chemin comme celui-ci.

################### 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"

Une solution existante consiste à utiliser la commande "SOURCE" et à importer le fichier de configuration avec ces variables. 'SOURCE path / to / file' Mais cette solution présente un problème de sécurité, car le fichier source peut contenir tout ce qu'un script Bash peut. Cela crée des problèmes de sécurité. Une personne malicieuse peut "exécuter" du code arbitraire lorsque votre script recherche son fichier de configuration.

Imaginez quelque chose comme ça:

 ################### 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 ~/*

Pour résoudre ce problème, nous pourrions vouloir autoriser uniquement les constructions sous la forme NAME=VALUEde ce fichier (syntaxe d'attribution de variable) et peut-être les commentaires (bien que techniquement, les commentaires ne soient pas importants). Ainsi, nous pouvons vérifier le fichier de configuration en utilisant une egrepcommande équivalente à grep -E.

C'est ainsi que j'ai résolu le problème.

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

dans Bash, pour générer la sortie d'une commande, au lieu d'un fichier:

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

référence

Conversion d'un fichier de paramètres en variables d'environnement

Habituellement, je procède à l'analyse au lieu de l'approvisionnement, pour éviter la complexité de certains artefacts dans mon fichier. Il me propose également des moyens de gérer spécialement les devis et autres choses. Mon objectif principal est de conserver tout ce qui vient après le «=» comme un littéral, même les guillemets et les espaces.

#!/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"

Notez la petite astuce que j'ai dû faire pour considérer mon texte cité comme un seul paramètre avec un espace pour ma cntparsfonction. Il y avait un niveau d'évaluation supplémentaire requis. Si je ne faisais pas cela, comme dans l'option 2, j'aurais passé 2 paramètres comme suit:

• "value
• content"

Les guillemets doubles lors de l'exécution de la commande entraînent la conservation des guillemets doubles du fichier de paramètres. Par conséquent, la 3e option échoue également.

L'autre option serait bien sûr de simplement ne pas fournir de variables entre guillemets, comme dans l'option 4, et ensuite de simplement vous assurer de les citer en cas de besoin.

Juste quelque chose à garder à l'esprit.

Recherche en temps réel

Une autre chose que j'aime faire est de faire une recherche en temps réel, en évitant l'utilisation de variables d'environnement:

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

Pas le plus efficace, mais avec des fichiers plus petits fonctionne très proprement.

Si les variables sont générées et non enregistrées dans un fichier, vous ne pouvez pas les diriger vers source. La façon trompeusement simple de le faire est la suivante:

some command | xargs

Le script contenant des variables peut être exécuté importé à l'aide de bash. Considérez le script-variable.sh

#!/bin/sh
scr-var=value

Considérez le script réel où la variable sera utilisée:

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

Pour éviter les conflits de noms, importez uniquement les variables dont vous avez besoin:

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

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