Comando coproc en Linux con ejemplos

El comando coproc en Linux es un comando de shell que nos permite crear un coproceso que está conectado al shell de invocación a través de dos conductos. Una de las canalizaciones nos permite enviar la entrada mientras que la otra nos permite leer la salida sin tener que recurrir a canalizaciones con nombre. El coproceso se ejecuta de forma asíncrona en una subcapa. Este comando se puede usar por encima de las versiones de bash 4.0.

Sintaxis:

coproc command args #first command
coproc name command args #second command

El primer comando se utiliza en el caso de comandos simples. No se debe dar nombre al comando porque en el caso de comando simple se interpreta como la primera palabra del comando simple. En el caso de comandos compuestos, se utiliza el segundo comando. Si no se proporciona el nombre, COPROC es el ‘nombre’ por defecto. Cuando se ejecuta el coproceso, se crea una array denominada ‘nombre’ (de forma predeterminada, COPROC si el nombre no se proporciona en el comando) en el contexto del shell en ejecución. El primer elemento de esta array es el descriptor de salida, mientras que el segundo elemento de la array es el descriptor de entrada del coproceso. Se establece una tubería bidireccional entre el shell de ejecución y el coproceso. Bash coloca los descriptores de archivo para esas tuberías en la array:

• name[0] es el descriptor de archivo para la tubería que está conectada a la salida estándar del coproceso en el shell de ejecución.
• name[1] es el descriptor de archivo para la canalización que está conectada a la entrada estándar del coproceso en el shell de ejecución.

Estas canalizaciones se establecen antes de que el comando realice cualquier redirección. Estos descriptores de archivo se pueden utilizar como argumentos para comandos de shell y redirecciones mediante expansiones de palabras estándar. La variable nombre_PID almacena el número de identificación del proceso. El comando incorporado de espera se puede usar para esperar a que el coproceso complete su ejecución. El comando coproc siempre devuelve el éxito, ya que se crea como un comando asíncrono. El estado de retorno de un coproceso es el mismo que el estado de salida del comando. 

Trabajando con el comando coproc

1. Como se puede ver en el código de ejemplo que se menciona a continuación, no se proporciona ningún nombre en el comando coproc, por lo que, de forma predeterminada, COPROC es el nombre de la array. COPROC[@] imprime los elementos de la array que almacena el descriptor de archivo que está conectado a la salida y entrada respectivamente. COPROC_PID almacena el número de identificación del proceso. COPROC[0] nos permite leer la salida del coproceso

coproc (echo $(whoami))                                   
echo "The coprocess array is ${COPROC[@]}"         
echo "The PID of the coprocess is ${COPROC_PID}"                                 
read -r o <&"${COPROC[0]}"
echo "The user is $o which is the output of the coprocess"

2. El código mencionado a continuación imprime geeksforgeeks como salida. La entrada a bash se proporciona mediante gfg[1], que es el descriptor de archivo para la tubería conectada a la entrada.

coproc gfg { bash ; }
echo 'echo geeksforgeeks' >&"${gfg[1]}"
read output <&"${gfg[0]}"
echo $output

3. Los descriptores de archivo del coproceso son accesibles solo para el proceso a partir del cual se generó el coproceso. No son heredados por subcapas (por ejemplo: cualquier comando que se inicia entre paréntesis se inicia en una nueva subcapa). Como se puede ver en el código mencionado a continuación, se muestra un error en el segundo caso, ya que el comando entre paréntesis se inicia dentro de un nuevo shell y los descriptores de archivos del coproceso son accesibles solo para el proceso desde el que se generó. 

coproc gfg ( read -r input; echo "${input}" )
echo "PID:${gfg_PID}"
#first case
echo "geeksforgeeks"  >&"${gfg[1]}"
read -r output1 <&"${gfg[0]}"
echo "The output of coprocess is ${output1}"
#second case                                     
(echo "geeksforgeeks"  >&"${gfg[1]}")    #This will cause an error                     
read -r output2 <&"${gfg[0]}"
echo "The output of coprocess is ${output2}"

4. El comando tr en el código mencionado a continuación reemplazará todas las instancias de la letra «a» en la entrada con la letra b. El descriptor de archivo se cierra con la instrucción exec. Tenga en cuenta que cerrar de esta manera está permitido en versiones de bash superiores a 4.3. Para las versiones anteriores a la 4.3, primero debe almacenar el descriptor del archivo en una variable y luego usar el comando exec.

coproc gfg { tr a b; }
echo abbaaabbb >&"${gfg[1]}"
exec {gfg[1]}>&-
cat <&"${gfg[0]}"

Ventaja del comando coproc sobre & operador

También se puede ejecutar un coproceso en segundo plano mediante el uso del operador &, que simplemente se puede agregar al comando. Los comandos como , y se pueden usar para traer el proceso al primer plano o enviarle señales. Pero esto no nos permite enviar entradas al comando de fondo o leer la salida de ese comando. Esto se puede lograr usando el comando coproc que se puede interpretar como si tuviera la misma función que un operador & con una tubería bidireccional establecida entre el shell en ejecución y el coproceso.