¿Cómo hacer una tubería bidireccional entre dos programas?

Todo el mundo sabe cómo hacer tubo unidireccional entre dos programas (bind stdoutde primera y stdinde segunda): first | second.

Pero, ¿cómo hacer una tubería bidireccional, es decir, un enlace cruzado stdiny stdoutdos programas? ¿Hay una manera fácil de hacerlo en un shell?

Si las tuberías en su sistema son bidireccionales (como lo son en Solaris 11 y algunos BSD al menos, pero no Linux):

cmd1 <&1 | cmd2 >&0

Pero cuidado con los callejones sin salida.

También tenga en cuenta que algunas versiones de ksh93 en algunos sistemas implementan tuberías ( |) utilizando un par de sockets . los pares de zócalos son bidireccionales, pero ksh93 cierra explícitamente la dirección inversa, por lo que el comando anterior no funcionaría con esos ksh93s incluso en sistemas donde las tuberías (como las crea la pipe(2)llamada al sistema) son bidireccionales.

Bueno, es bastante "fácil" con tuberías con nombre ( mkfifo). Pongo comillas fáciles porque a menos que los programas estén diseñados para esto, es probable un punto muerto.

mkfifo fifo0 fifo1
( prog1 > fifo0 < fifo1 ) &
( prog2 > fifo1 < fifo0 ) &
( exec 30<fifo0 31<fifo1 )      # write can't open until there is a reader
                                # and vice versa if we did it the other way

Ahora, normalmente hay buffering involucrado en escribir stdout. Entonces, por ejemplo, si ambos programas fueran:

#!/usr/bin/perl
use 5.010;
say 1;
print while (<>);

esperarías un bucle infinito. Pero en cambio, ambos se estancarían; necesitaría agregar $| = 1(o equivalente) para desactivar el almacenamiento en búfer de salida. El punto muerto se debe a que ambos programas están esperando algo en stdin, pero no lo ven porque está en el búfer stdout del otro programa y aún no se ha escrito en la tubería.

Actualización : incorporando sugerencias de Stéphane Charzelas y Joost:

mkfifo fifo0 fifo1
prog1 > fifo0 < fifo1 &
prog2 < fifo0 > fifo1

hace lo mismo, es más corto y más portátil.

No estoy seguro de si esto es lo que estás tratando de hacer:

nc -l -p 8096 -c second &
nc -c first 127.0.0.1 8096 &

Esto comienza con la apertura de un socket de escucha en el puerto 8096, y una vez que se establece una conexión, genera el programa secondcon su stdinmedida que la corriente de salida y stdoutcomo entrada de corriente.

Luego, ncse inicia un segundo que se conecta al puerto de escucha y genera el programa firstcon su stdoutentrada de flujo y su stdinsalida de flujo.

Esto no se hace exactamente usando una tubería, pero parece hacer lo que necesita.

Como esto usa la red, esto se puede hacer en 2 computadoras remotas. Esta es casi la forma en que funcionan un servidor web ( second) y un navegador web ( first).

Puedes usar pipexec :

$ pipexec -- '[A' cmd1 ] '[B' cmd2 ] '{A:1>B:0}' '{B:1>A:0}'

bashla versión 4 tiene un coproccomando que permite que esto se haga en puro bashsin canalizaciones con nombre:

coproc cmd1
eval "exec cmd2 <&${COPROC[0]} >&${COPROC[1]}"

Algunas otras conchas también pueden funcionar coproctambién.

A continuación se muestra una respuesta más detallada, pero encadena tres comandos, en lugar de dos, lo que hace que sea un poco más interesante.

Si está contento de usar también caty stdbufluego construir, puede ser más fácil de entender.

Versión bashcon caty stdbuffácil de entender:

# start pipeline
coproc {
    cmd1 | cmd2 | cmd3
}
# create command to reconnect STDOUT `cmd3` to STDIN of `cmd1`
endcmd="exec stdbuf -i0 -o0 /bin/cat <&${COPROC[0]} >&${COPROC[1]}"
# eval the command.
eval "${endcmd}"

Tenga en cuenta que debe usar eval porque la expansión variable en <& $ var es ilegal en mi versión de bash 4.2.25.

Versión usando pure bash: divídase en dos partes, inicie la primera tubería bajo coproc, luego almuerce la segunda parte, (ya sea un solo comando o una tubería) volviendo a conectarla a la primera:

coproc {
    cmd 1 | cmd2
}
endcmd="exec cmd3 <&${COPROC[0]} >&${COPROC[1]}"
eval "${endcmd}"

Prueba de concepto:

archivo ./prog, solo un programa ficticio para consumir, etiquetar y volver a imprimir líneas. Usar subconjuntos para evitar problemas de almacenamiento en búfer puede ser excesivo, no es el punto aquí.

#!/bin/bash
let c=0
sleep 2

[ "$1" == "1" ] && ( echo start )

while : ; do
  line=$( head -1 )
  echo "$1:${c} ${line}" 1>&2
  sleep 2
  ( echo "$1:${c} ${line}" )
  let c++
  [ $c -eq 3 ] && exit
done

file ./start_cat Esta es una versión que usa bash, catystdbuf

#!/bin/bash

echo starting first cmd>&2

coproc {
  stdbuf -i0 -o0 ./prog 1 \
    | stdbuf -i0 -o0 ./prog 2 \
    | stdbuf -i0 -o0 ./prog 3
}

echo "Delaying remainer" 1>&2
sleep 5
cmd="exec stdbuf -i0 -o0 /bin/cat <&${COPROC[0]} >&${COPROC[1]}"

echo "Running: ${cmd}" >&2
eval "${cmd}"

o archivo ./start_part. Esta es una versión que usa puro bashsolamente. Para fines de demostración, todavía estoy usando stdbufporque su programa real tendría que lidiar con el almacenamiento interno de todos modos para evitar el bloqueo debido al almacenamiento en búfer.

#!/bin/bash

echo starting first cmd>&2

coproc {
  stdbuf -i0 -o0 ./prog 1 \
    | stdbuf -i0 -o0 ./prog 2
}

echo "Delaying remainer" 1>&2
sleep 5
cmd="exec stdbuf -i0 -o0 ./prog 3 <&${COPROC[0]} >&${COPROC[1]}"

echo "Running: ${cmd}" >&2
eval "${cmd}"

Salida:

> ~/iolooptest$ ./start_part
starting first cmd
Delaying remainer
2:0 start
Running: exec stdbuf -i0 -o0 ./prog 3 <&63 >&60
3:0 2:0 start
1:0 3:0 2:0 start
2:1 1:0 3:0 2:0 start
3:1 2:1 1:0 3:0 2:0 start
1:1 3:1 2:1 1:0 3:0 2:0 start
2:2 1:1 3:1 2:1 1:0 3:0 2:0 start
3:2 2:2 1:1 3:1 2:1 1:0 3:0 2:0 start
1:2 3:2 2:2 1:1 3:1 2:1 1:0 3:0 2:0 start

Eso lo hace.

Un bloque de construcción conveniente para escribir tales tuberías bidireccionales es algo que conecta el stdout y el stdin del proceso actual. Llamémoslo ioloop. Después de llamar a esta función, solo necesita iniciar una tubería normal:

ioloop &&     # stdout -> stdin 
cmd1 | cmd2   # stdin -> cmd1 -> cmd2 -> stdout (-> back to stdin)

Si no desea modificar los descriptores del shell de nivel superior, ejecute esto en un subshell:

( ioloop && cmd1 | cmd2 )

Aquí hay una implementación portátil de ioloop usando una tubería con nombre:

ioloop() {
    FIFO=$(mktemp -u /tmp/ioloop_$$_XXXXXX ) &&
    trap "rm -f $FIFO" EXIT &&
    mkfifo $FIFO &&
    ( : <$FIFO & ) &&    # avoid deadlock on opening pipe
    exec >$FIFO <$FIFO
}

La canalización con nombre existe en el sistema de archivos solo brevemente durante la configuración de ioloop. Esta función no es POSIX porque mktemp está en desuso (y es potencialmente vulnerable a un ataque racial).

Es posible una implementación específica de Linux usando / proc / que no requiera una tubería con nombre, pero creo que esta es más que suficiente.

También hay

• dpipe, la "tubería bidireccional", incluida en el paquete vde2 e incluida en los sistemas actuales de administración de paquetes de distribución .

  dpipe processA = processB

• socat , la herramienta de conectar todo a todo.

  socat EXEC:Program1 EXEC:Program2

Como @ StéphaneChazelas señala correctamente en los comentarios, los ejemplos anteriores son la "forma base", tiene buenos ejemplos con opciones en su respuesta para una pregunta similar .

Hay muchas respuestas geniales aquí. Así que solo quiero agregar algo para jugar fácilmente con ellos. Supongo stderrque no se redirige a ninguna parte. Cree dos scripts (digamos a.sh y b.sh):

#!/bin/bash
echo "foo" # change to 'bar' in second file

for i in {1..10}; do
  read input
  echo ${input}
  echo ${i} ${0} got: ${input} >&2
done

Luego, cuando los conecte de cualquier manera que debería ver en la consola:

1 ./a.sh got: bar
1 ./b.sh got: foo
2 ./a.sh got: foo
2 ./b.sh got: bar
3 ./a.sh got: bar
3 ./b.sh got: foo
4 ./a.sh got: foo
4 ./b.sh got: bar
...