J'utilise souvent plus d'un terminal (ou émulateur de terminal) à la fois; et alors que dans X je peux copier-coller des commandes, en plus d'être peu pratique, cela ne fonctionne évidemment pas sur le vrai TTY. La première idée qui me vient est quelque chose comme ça :
command > /dev/sometty
Malheureusement, la command est exécuté avant il est canalisé, et pas d'astuces comme echo `command` fonctionnera, peu importe le nombre de caractères bash bizarres ($ , ` , " , etc.) sont là. Donc /dev/sometty obtient simplement du texte.
Le problème est que, parfois, cela vaut même la peine pour moi de diriger ces commandes dans un fichier, de le rendre exécutable, etc., ou en bref :de créer un script et de l'exécuter à partir du terminal approprié. Mais c'est beaucoup de travail. J'ai pensé à faire un script pour créer ces fichiers, pour une instruction :
termpipe -e "command1\ncommand2\"command 1 argument\\n(s)\"" -t /dev/sometty
cela ferait quelque chose comme :
- dirigez les commandes vers, par exemple,
/tmp/termpipe-20140208-153029-1.sh - rendre le fichier exécutable
- exécuter le fichier dans le terminal approprié
- supprimer le script lorsqu'il a fini de s'exécuter
AFAIK, le problème est dans 3. :cela ne résout aucun problème, car j'aurais besoin d'un autre termpipe instance pour exécuter la première sur le terminal approprié. Et un pour celui-là. Et un autre pour ça, ad infinitum . Donc, cela ne peut pas fonctionner. Ou peut-il ?…
La solution pourrait être d'utiliser un tube nommé par terminal, et quand chacun démarre, un script dirait au tube de transmettre tout ce qu'il reçoit au terminal, puis de l'exécuter (comme une sorte de démon ).
Je pense que cela pourrait fonctionner mais je ne sais pas comment configurer le script initial. Comment puis-je? Comment puis-je dire au FIFO de donner des commandes canalisées pour que le terminal respectif s'exécute ? Je ne connais pas beaucoup Bash, donc j'apprécierais des explications complètes.
Réponse acceptée :
Suite à cela, on peut très bien faire en sorte que votre dernier plan fonctionne. Pour que la commande à envoyer ne soit pas traitée par le shell, elle doit être sous la forme d'une chaîne lorsqu'elle atteint le tube (donc echo "command" , pas echo `command` ). Ensuite, il doit être lu par un processus d'arrière-plan (comme un démon , mais pas nécessairement) démarré dans le terminal approprié. Il doit être évalué par le même processus.
Mais c'est un passe-partout pour avoir un script par pipe. Alors généralisons la création d'un script comme term-pipe-r.sh (n'oubliez pas de chmod +x ça !) :
#!/bin/bash
pipe=$1 # the pipe name is the first argument
trap 'rm -f "$pipe"' EXIT # ignore exit and delete messages until the end
if [[ ! -p $pipe ]]; then # if the pipe doesn't exist, create it
mkfifo $pipe
fi
while true # cycle eternally..
do
if read line <$ pipe; then
if [[ "$line" == 'close the term-pipe pipe' ]]; then
break
# if the pipe closing message is received, break the while cycle
fi
echo # a line break should be used because of the prompt
eval $line # run the line: as this script should be started
fi # in the target terminal,
done # the line will be run there.
echo "<pipe closing message>" # custom message on the end of the script
Alors dites que vous voulez /dev/tty3 pour recevoir des commandes :allez-y, faites
./term-pipe-r.sh tty3pipe & # $1 will be tty3pipe (in a new process)
Et pour envoyer des commandes, depuis n'importe quel terminal (même de lui-même):
echo "command" > tty3pipe
ou pour y exécuter un fichier :
cat some-script.sh > tty3pipe
Notez que cette tuyauterie ignore les fichiers comme .bashrc , et les alias qu'il contient, tels que alias ls='ls --color' . J'espère que cela aidera quelqu'un.
Modifier (remarque :avantage du non-démon ):
Ci-dessus, j'ai parlé du lecteur de pipe n'étant pas un démon nécessairement, mais en fait, j'ai vérifié les différences, et il s'avère qu'il est bien préférable d'être un simple processus de fond dans ce cas. Parce que de cette façon, lorsque vous fermez le terminal, un EXIT signal (SIGHUP , SIGTERM , ou autre) est également reçu par le script, et le tube est ensuite supprimé (voir la ligne commençant par trap dans le script) automatiquement, en évitant un processus et un fichier inutiles (et peut-être d'autres s'il y avait une telle redirection vers le tube inutile).
Modifier (automatisation) :
Pourtant, il est ennuyeux de devoir exécuter un script que vous (moi, du moins) voulez probablement la plupart du temps. Alors, automatisons-le ! Il devrait démarrer dans n'importe quel terminal, et une chose que tous lisent est .bashrc . De plus, ça craint d'avoir à utiliser ./term-pipe-r.sh . Alors, on peut faire :
cd /bin # go to /bin, where Bash gets command names
ln -s /directory/of/term-pipe-r.sh tpr # call it tpr (terminal pipe reader)
Maintenant, pour l'exécuter, vous n'auriez besoin que de tpr tty3pipe & dans /dev/tty3 quand tu veux. Mais pourquoi faire cela alors que vous pouvez le faire automatiquement ? Cela devrait donc être ajouté à .bashrc . Mais attendez :comment saura-t-il le nom du tuyau ? Il peut baser le nom sur le TTY (qui peut être connu avec le tty commande), en utilisant de simples REGEX dans sed (et quelques astuces). Ce que vous devez ajouter à ~/.bashrc sera alors :
pipe="$(sed 's/\/dev\///' <<< `tty` | sed 's/\///')pipe"
# ^^^- take out '/dev/' and other '/', add 'pipe'
tpr $pipe & # start our script with the appropriate pipe name