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 commande source 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 dans bash avec un fichier de configuration qui contenait 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. 'Chemin SOURCE / vers / Fichier' Mais cette solution a un problème de sécurité, parce que le le fichier source peut contenir tout ce qu'un script Bash peut contenir. Qui crée des problèmes de sécurité. Une personne de malicicios peut" exécuter " du code arbitraire lorsque votre script cherche son fichier de configuration.

imaginez quelque chose comme ceci:

 ################### 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 cela, nous pourrions ne permettre que les constructions sous la forme NAME=VALUE dans ce fichier (syntaxe d'assignation des variables) et peut-être des commentaires (bien que techniquement, les commentaires ne soient pas importants). Donc, nous pouvons vérifier le fichier de configuration en utilisant egrep équivalent commande de grep -E .

C'est comme ça 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

en Bash, à la source de certains sortie de la 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

si les variables sont générées et non sauvegardées dans un fichier, vous ne pouvez pas les insérer dans source . La manière trompeusement simple de le faire est celle-ci:

some command | xargs

config.env

var1='foo'

script.sh

export $(cat config.env | grep -v ^# | xargs)
echo $var1

Conversion de fichier de paramètres de variables d'Environnement

en général, je passe parsing au lieu de sourcing, pour éviter les complexités de certains artefacts dans mon dossier. Il m'offre également des façons de gérer spécialement les citations et d'autres choses. Mon but principal est de garder 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 : "
  echo "  > par2 : "

  if [[ $# = 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/^\([^=]*\)=\(.*\)$//')
    val=$(echo "${line}" | sed -e 's/^\([^=]*\)=\(.*\)$//' -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 le petit truc que j'ai dû faire pour considérer mon texte cité comme un paramètre unique avec espace pour ma fonction cntpars . Un niveau d'évaluation supplémentaire était requis. Si Je ne le faisais pas, comme dans L'Option 2, j'aurais passé les 2 paramètres suivants:

• "value
• content"

la double citation lors de l'exécution de la commande permet de conserver les doubles citations du fichier paramètre. Par conséquent, la troisième Option échoue également.

l'autre option serait cours tout simplement pas fournir variables entre guillemets doubles, comme dans l'Option 4, et puis juste pour s'assurer que vous 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, évitant l'utilisation de variables d'environnement:

lookup() {
if [[ -z "" ]] ; then
  echo ""
else
  ${AWK} -v "id=" 'BEGIN { FS = "=" }  == id { print  ; exit }' 
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.

le script contenant les variables peut être exécuté importé en utilisant bash. Considérons le script-variable.sh

#!/bin/sh
scr-var=value

d'Envisager le script en lui-même où la variable sera utilisée :

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