deuxième “envoyer la commande” attendons à ce que le script n'est pas en attente pour terminer la Sortie de la première commande

J'ai un très petit script expect . Le flux est comme suit

ssh à la machine à distance
Exécuter une commande et après l'exécution de la commande, vous serez dans un autre prompt ( invite de nom est Enter cmd>.
Sur le Enter cmd> invite, j'ai besoin d'exécuter de nombreuses commandes

J'ai donc conçu ce script

#!/usr/bin/expect

 set FULL_CMD { #cmd1 #cmd2 #cmd3  }
 puts "STARTING......."

 log_file myfile.log ;# <<< === append output to a file
 spawn ssh tempuser\@dummyserver
 match_max  100000000

 expect "password:"
 send "temppasswd\r"
expect  "*temp*"
 send "cd \/home\r"
 expect "*temp*"
send "new cmd prompt\r"
expect "Enter cmd>"

foreach tempcmd $FULL_CMD {
 send "${tempcmd} \r "
 expect -exact  "Enter cmd>\r"
 send -- "\r"
expect eof }

send "q"
send "exit\r"

puts "I HAVE ENDED......."

Mon problème: Fait l'O/P de la première commande cmd#1 est très long et je peux voir que le fait de s'attendre script n'est pas d'attente pour l'O/P de la première commande complète et envoie le deuxième commande cmd#2 après un certain temps.

Ce script fonctionne très bien sur les systèmes où l'O/P de cmd#1 est petit, mais sur les systèmes où l'O/P de cmd#1 est très grand (disons 1000000 lignes), il a du mal, à savoir les questions de la première commande cmd#1 et l'O/P suit, mais avant de revenir à Enter cmd> invite, le script questions de la deuxième commande cmd#2

Comment puis-je m'assurer que la commande cmd#2 est envoyée seulement après la sortie de cmd#1 complète?

InformationsquelleAutor user3387487 | 2014-03-06

expect linux

5

Essayez de définir un délai d'attente au départ:
```
set timeout 60
```
ou de l'utilisation -1 à attendre indéfiniment.
- Salut Marc, Merci pour la suggestion. Mais ce que je comprends de temporisation / -1 est utilisé pour le traitement de la ssh timeout/ pendaison de problème. Mais mon problème n'est pas lié o ssh pendaison / délai d'attente. Mon problème dans le script ci-dessus est que je suis en cours d'exécution #cmd1 #cmd2 #cmd3 de "Entrez cmd>" prompte et tandis que la #cmd1 est toujours en cours d'exécution ( c'est à dire encore en production à la sortie), le script exécute la deuxième commande #cmd2, c'est à dire que le script n'a pas d'attendre la sortie de la première commande
- Ainsi, le délai d'attente par défaut est de 10 secondes. Donc, essayez de placer deux commandes dans votre tableau "le sommeil de 20" et "le sommeil de 20". Puis exécuter votre travail et de voir combien de temps cela prend. Puis définissez le délai de 60, comme je l'ai suggéré et l'exécuter à nouveau. Vous allez bientôt voir ce qui se passe.
- Salut marc, je veux faire de ce portable dans d'autres systèmes, toutefois, en fonction interne de la configuration du système , certains ont de petites sortie de #cmd1 et certains ont trop longtemps de sortie.Par exemple, dans certains système de la #cmd1 dure 3 minustes ( disons de sortie est de 1000000 lignes) où, comme dans certains, la sortie est à seulement quelques centaines.Donc, si j'ai de sommeil de 3 minutes, alors il sera okey pour le système qui ont une longue sortie de #cmd1, mais pour le système qui ont un plus petit de la sortie de #cmd1 le script va attendre 3 minutes pour terminer, bien que le #cmd1 sera achevé en 1 min. Si le script fonctionne au ralenti pendant 2 minutes inutilement
- Non, vous n'êtes pas à me comprendre. Je suggère un test rapide seulement. Voir si les délais d'expiration sont le problème en changeant temporairement votre script à exécuter "dormir 20" deux fois c'est tout. Si elle tourne dans les 40 secondes, les délais d'attente ne sont pas le problème. Si elle tourne dans les 20 secondes, le problème, c'est que vous avez besoin de changer votre délai d'attente à partir de la valeur par défaut de 10 secondes par commande - qui est ce que je soupçonne de la question avec votre script réel est.
- Si une tâche prend 5 secondes et le délai d'attente est de 20 secondes, la tâche suivante sera exécuté après 5 secondes, donc il n'y a pas de pénalité pour avoir un plus grand délai d'attente - il seulement définit le montant maximum de temps, si la commande se termine dans moins c'est très bien.
- Salut Marc,Merci pour la suggestion. Je suis novice de s'attendre à ce langage de script, pouvez-vous s'il vous plaît suggérer où je dois changer le code et que dois-je mettre la valeur. le ci-dessus est mon vrai script. (non modifiée).en situation réelle, le #cmd1, dans certains systèmes, prendre jusqu'à 3 minutes à compléter
- Changer #cmd1 à "dormir 20" et #cmd2 à "dormir 20"
- je l'ai eu. Merci mark.mais le #cmd1 et #cmd2 sont exécutées dans l'invite de commande "Emter cmd>", ce n'est pas invite bash, Donc si je comprends bien, si je remplace #cmd1 et #cmd2 avec le sommeil et le 20, il sera exécuté "Entrez cmd>" invite de commandes. mais cette invite "Entrer cmd>" ne peuvent pas gérer la commande de mise en veille, il ne peut gérer que quelques cmd. BTW, je suis de sortir de la station et sera de retour le jour après demain. en cas de progrès ou de toute autre suggestion de votre part s'il vous plaît laissez-moi savoir. Merci plein à vous comme toujours
InformationsquelleAutor Mark Setchell
0

Pourquoi avez-vous "attendent des expressions du folklore" dans ta boucle for?
```
foreach tempcmd $FULL_CMD {
  send "$tempcmd\r"
  expect "Enter cmd>"
  send -- "\r"         # why do you need this?
}
```
Il est intelligent, alors que le développement de votre programme, pour activer le débogage: ajouter cette près de la partie supérieure: exp_internal 1
- J'ai juste copié l'exemple de l'un des codes disponibles dans google. toutefois, dans les scénarios actuels dans le système de travail le script est à l'arrêt pendant environ 5 secondes avant d'exécuter la commande suivante ( système où #cmd1 O/P est petit), mais si je supprime le fait de s'attendre eof puis son pas d'attente du tout, juste l'exécution de toutes les commandes rapide. J'ai donc préférée à l'utilisation de l'attendre expressions du folklore. Sur "envoyer -- "\r" j'ai essayé de changer quelque chose à vérifier si cela fonctionne, mais toujours le même
InformationsquelleAutor glenn jackman
0

Le problème réside dans votre foreach tempcmd $FULL_CMD boucle:
```
foreach tempcmd $FULL_CMD {
  send "${tempcmd} \r "
  expect -exact  "Enter cmd>\r"
  send -- "\r"
expect eof }
```
Le problème, c'est que vous êtes expecting "Enter cmd>\r", mais vous n'obtiendrez jamais le \r dans votre sortie.

Ce que vous devriez expect est "Enter cmd>$", où la $ implique la fin de la commande en cours de sortie (et non pas '\nor '\r' oreof`).
```
foreach tempcmd $FULL_CMD {
    send "${tempcmd} \r "
    expect -exact  "Enter cmd>$" # Check for spaces after '>' and fix as required
    send -- "\r"
    # expect eof
}
```
Comme pour expect eof, elle correspond à la fin du flux d'entrée qui est reliée à la sortie du processus générés dynamiquement. Il ne fait correspondre une fois le engendré un processus se termine, il n'est donc pas utiliser ici

InformationsquelleAutor Samveen

Vous devez vous connecter pour publier un commentaire.