comment trouver un csh de script en bash pour définir l'environnement

Nous avons Oracle Solaris, et le shell par défaut de csh. Ainsi, le script de connexion définit la oracle_home, oracle_sid dans csh aussi. Mais je n'aime pas les csh et que vous voulez utiliser bash pour faire mon travail. Alors, comment à la source de la csh login script en bash?

e.g, la suivante est ce que dans le .cshrc fichier. Et quand utiliser bash, j'aimerais utiliser ces variables. Une façon est de copier les variables de nouveau et utiliser la commande bash, tels que l'export ORACLE_SID=TEST. Mais cela va nous obliger à conserver deux copies des fichiers. Et quand nous changeons le nom de base de données, ou de mettre à niveau la base de données, j'ai besoin de maintenir le bash de connexion fichier séparément. C'est agréable d'utiliser quelque chose comme

source .cshr de bash, mais il ne fonctionne pas.

setenv ORACLE_SID TEST 
setenv ORACLE_HOME /oracle/TEST/home/produits/10204 
setenv EPC_DISABLED VRAI 
setenv MANPATH /usr/local/man:/usr/share/man 
setenv de l'ÉDITEUR vi 
setenv LD_LIBRARY_PATH $ORACLE_HOME/lib:/usr/sfw/lib/64 
setenv NLS_LANG AMERICAN_AMERICA.UTF8 
setenv NLS_DATE_FORMAT "DD-MON-RR"

Plus approprié pour le Super-Utilisateur ou le Serveur Faute?

InformationsquelleAutor Daniel | 2010-04-26

bash csh

Dans votre ~/.bashrc (ou le premier de ~/.bash_profile, ~/.bash_login, et ~/.profile qui existe) de la source de ce script en utilisant quelque chose comme . ~/bin/sourcecsh:

#!/bin/bash
# This should be sourced rather than executed
while read cmd var val
do
    if [[ $cmd == "setenv" ]]
    then
        eval "export $var=$val"
    fi
done < ~/.cshrc

Cette version élimine le mal eval:

#!/bin/bash
# This should be sourced rather than executed
# yes, it will be sourcing within sourcing - what so(u)rcery!
source /dev/stdin < \
<(
    while read cmd var val
    do
        if [[ $cmd == "setenv" ]]
        then
             echo "export $var=$val"
        fi
    done < cshrc
)

Edit:

Sans sourcing stdin:

while read cmd var val
do
    if [[ $cmd == "setenv" ]]
    then
        declare -x "$var=$val"
    fi
done < cshrc

sympa... je l'aime car c'est du pur bash (le mien utilise sed)... je dois avouer que je préfère encore ma version (assez similaires), principalement parce qu'elle maintient la liste des commandes dans un fichier pour plus tard, de dépannage ou de l'environnement de restauration, juste au cas où 🙂
Je vais voter pour la première version-sourcing stdin est au moins aussi mal-ventre comme eval.

InformationsquelleAutor Dennis Williamson

4

Je suis dans le même bateau. Un collègue m'a montré les éléments suivants:

Commencer dans bash, sans les trucs en thwe environnement:
```
bash> echo $$
12632
bash> echo $FOO
```
Voici le fichier csh qui devient source avais:
```
bash> cat setup-env.csh
setenv FOO "some csh stuff"
echo FOO=$FOO in csh
```
Voici la commande:
```
bash> csh -c 'source setup-env.csh;exec bash'
```
Chercher à la sortie de csh
```
FOO=some csh stuff in csh
```
Et chercher à la sortie de la nouvelle shell bash
```
  bash> echo $$
  13487
  bash> echo $FOO
  some csh stuff
```
De quitter et de revenir à l'original shell bash
```
bash> exit
exit
bash> echo $$
12632
bash> 
```
Note le echo $$ pour voir l'Id de processus, de sorte que nous pouvons voir qu'ils sont différents des shell processus.

Mon collègue utilise assez sur ce qu'il le met dans un alias, comme:
```
# make csh environment scripts useable (sourceable) from bash function 
# from Phil McCoy, Wed Nov  9 2011
source_csh () {
   exec csh -c " source $*; setenv ALREADY_SOURCED \"$ALREADY_SOURCED:$*:\"; exec bash"
}
# sounds like a great idea to do source_csh .cshrc or .login
# but naively done is infinitely recursive, 
# since the exec'ed bash will run .bashrc
```
Malheureusement, j'ai trouvé que j'ai souvent besoin non seulement de la variable d'environnement de l'installation, mais aussi d'alias de l'installation, comme dans le paquet pour les modules http://modules.sourceforge.net/.

J'ai été en mesure d'automatiser cette "csh script source de recettes" à l'aide de Perl Attendre. Mais je n'ai pas été capable d'être aussi interactif que je le voudrais, à l'exception de ce qui précède.
- Je suis un grand fan des modules de colis et je suis surpris de voir plus de gens ne l'utilisent pas. Rendre les choses shell agnostique est juste une bonne chose à faire.
InformationsquelleAutor Krazy Glew
3

Que diriez-vous simplement la définition d'une fonction appelée setenv, comme
```
setenv() {
  echo setting $1 to $2
  export $1=$2
}
```
et puis la recherche .cshrc fichier.

Quand je le faire en bash, je reçois
```
[dws@oxygen ual-read-only]$ source cshrc
setting ORACLE_SID to TEST
setting ORACLE_HOME to /oracle/TEST/home/products/10204
setting EPC_DISABLED to TRUE
setting MANPATH to /usr/local/man:/usr/share/man
setting EDITOR to vi
setting LD_LIBRARY_PATH to /oracle/TEST/home/products/10204/lib:/usr/sfw/lib/64
setting NLS_LANG to AMERICAN_AMERICA.UTF8
setting NLS_DATE_FORMAT to DD-MON-RR
[dws@oxygen ual-read-only]$ env | grep ORACLE
ORACLE_SID=TEST
ORACLE_HOME=/oracle/TEST/home/products/10204
```
- De près, mais pas de cigare. (1) quelques-uns des csh source des scripts de définir des alias - et je ne sais pas comment faire pour exporter des alias de csh de retour à l'appel de la coquille comme bash. Je suppose que c'est juste une simple question de programmation pour traduire tout csh alias un alias bash, et vice-versa (le second pour l'appelant de nouveaux csh source des scripts). (2) depuis mon shell d'ouverture de session supplémentaires encvironmenht variables, j'ai besoin de la vider d'abord. Et c'est ce que je demande. (3), oh, viens de remarquer exactement ce que vous faites: oui, j'ai eu un setenv en bash pour de nombreuses années maintenant. (En fait, depuis avant bash existait, en ksh.)
InformationsquelleAutor Dave Wade-Stein
2

Dans votre bash .profile, vous pouvez effectuer les opérations suivantes:
```
cat .cshrc | sed 's/setenv\s+(\S+)\s+(.*)$/set $1=$2; export $1/' > $HOME/.env_from_csh
source $HOME/.env_from_csh
```
- C'est aussi cool, je préfère ne pas créer des fichiers inutiles. Pas sûr de savoir si nous pouvons utiliser un tuyau pour éviter que le fichier temporaire.
- Inutile d'utiliser des cat. Bash ne pas utiliser set de cette façon. export peut prendre le nom de la variable et la cession de tous à la fois. Vous devez utiliser une version différente de sed car qui ressemble à la syntaxe de Perl. Vous avez besoin d'utiliser -r ou échapper à l'parenthèses et les signes plus. Vous pouvez supprimer le fichier temporaire comme ceci: source /dev/stdin < <(sed 's/setenv\s\+$\S\+$\s\+$.*$$/export \1=\2/' .cshrc)
- et Daniel - j'ai l'habitude de voulez "junk" fichier temporaire 🙂
- source /dev/stdin < <(sed 's/setenv\s\+$\S\+$\s\+$.*$$/export \1=\2/' .cshrc | tee $HOME/.env_from_csh)
- neat!
InformationsquelleAutor DVK
1

Seule façon que je peux penser à faire il serait à la charge de csh et ensuite appeler bash à partir de ce nouveau shell. De cette façon, le csh a pu analyser ce fichier, puis le bash qu'il engendre n'héritent que de l'environnement en tant que bien.
- Dans le code: (cat .cshrc; echo exec $SHELL) | csh
InformationsquelleAutor sblom
0

Pour quelque chose de petit, il est commun de maintenir deux scripts d'installation, un pour les poissons et dérivés, des coquillages, et un pour le csh et tcsh. Comme vous le mentionnez, qui crée le risque de les deux scripts de sortir de synchronisation -- sauf vous générer l'un de l'autre, ou de générer à la fois à partir d'une source commune.

Ce met à la charge du responsable du script de configuration(s), plutôt que sur chaque utilisateur qui a besoin de les utiliser.

InformationsquelleAutor Keith Thompson
0

Il y a un module disponible par lequel vous pouvez source même fichier où vous voulez dans le script perl. Et vous obtiendrez tous les chemins d'environnement disponibles dans votre fichier csh.
```
Source::Shell
```
Passer par un peu de documentation pour son utilisation.

InformationsquelleAutor Mak_Thareja
-1

Juste d'avoir une "#!/bin/tcsh" ou une déclaration similaire disponible au début de la CSH script en conjonction avec rendre le script exécutable résolu le problème pour moi. Je pourrais appeler directement le script CSH à partir de bash dans ce cas.

Comme un exemple, j'ai eu à exécuter des outils.csh à partir d'un script bash appelé setup.sh. J'ai fait quelque chose comme ça dans le script bash:
```
if [ -z \`head -1 tools.csh | grep '^#!'\` ];
then
   TCSH=\`which tcsh\`;
   echo "'#!'$TCSH" > tools.csh.temp;
   cat tools.csh >> tools.csh.temp;
   mv tools.csh.temp tools.csh;
fi;
chmod 755 tools.csh;
./tools.csh
# now I have all the setenv commands effective ...
```
- Si ./tools.csh définit les variables d'environnement, ils ne être visible à partir de l'appel de la coquille. Si les commandes qui dépend de ces variables d'environnement sont tous dans ./tools.csh, c'est ok.
InformationsquelleAutor Somesh
-4

Trouver un fichier csh en bash ne fonctionnera pas. Vous pouvez modifier la valeur par défaut le shell de connexion de csh de bash si vous êtes plus à l'aise dans bash. Vous pouvez utiliser chsh ou un admin de le changer pour vous.
```
chsh -s /usr/local/bin/bash 
```
InformationsquelleAutor Sid Heroor

Vous devez vous connecter pour publier un commentaire.