bash – Citando en las construcciones de tipo ssh $ host $ FOO y ssh $ host "sudo su user -c $ FOO"

Pregunta:

A menudo termino emitiendo comandos complejos sobre ssh; estos comandos implican canalizar a una línea awk o perl y, como resultado, contienen comillas simples y $. No he podido descifrar una regla estricta y rápida para hacer las citas correctamente, ni he encontrado una buena referencia para ello. Por ejemplo, considere lo siguiente:

# what I'd run locally:
CMD='pgrep -fl java | grep -i datanode | awk '{print $1}'
# this works with ssh $host "$CMD":
CMD='pgrep -fl java | grep -i datanode | awk '"'"'{print $1}'"'"

(Tenga en cuenta las comillas adicionales en la declaración awk).

Pero, ¿cómo hago para que esto funcione, por ejemplo, ssh $host "sudo su user -c '$CMD'" ? ¿Existe una receta general para administrar cotizaciones en tales escenarios? …

Respuesta:

Tratar con múltiples niveles de citas (en realidad, múltiples niveles de análisis / interpretación) puede resultar complicado. Es útil tener en cuenta algunas cosas:

  • Cada "nivel de cotización" puede involucrar potencialmente un idioma diferente.
  • Las reglas de cotización varían según el idioma.
  • Cuando se trabaja con más de uno o dos niveles anidados, generalmente es más fácil trabajar "desde abajo hacia arriba" (es decir, desde el más interno hasta el más externo).

Niveles de cotización

Veamos sus comandos de ejemplo.

pgrep -fl java | grep -i datanode | awk '{print $1}'

Su primer comando de ejemplo (arriba) usa cuatro idiomas: su shell, la expresión regular en pgrep , la expresión regular en grep (que puede ser diferente del lenguaje de expresiones regulares en pgrep ) y awk . Hay dos niveles de interpretación involucrados: el shell y un nivel después del shell para cada uno de los comandos involucrados. Solo hay un nivel explícito de citas (citas de shell en awk ).

ssh host …

A continuación, agregó un nivel de ssh en la parte superior. Este es efectivamente otro nivel de shell: ssh no interpreta el comando en sí, lo entrega a un shell en el extremo remoto (a través de (por ejemplo) sh -c … ) y ese shell interpreta la cadena.

ssh host "sudo su user -c …"

Luego preguntó acerca de agregar otro nivel de shell en el medio usando su (a través de sudo , que no interpreta sus argumentos de comando, por lo que podemos ignorarlo). En este punto, tienes tres niveles de anidación en curso ( awk → shell, shell → shell ( ssh ), shell → shell ( su user -c ), por lo que te aconsejo que uses el enfoque "bottom, up". Asumiré que sus shells son compatibles con Bourne (por ejemplo, sh , ash , dash , ksh , bash , zsh , etc.) Algún otro tipo de shell ( fish , rc , etc.) puede requerir una sintaxis diferente, pero el método aún se aplica.

De abajo hacia arriba

  1. Formule la cadena que desea representar en el nivel más interno.
  2. Seleccione un mecanismo de citas del repertorio de citas del siguiente idioma más alto.
  3. Cotice la cadena deseada de acuerdo con su mecanismo de cotización seleccionado.
    • A menudo hay muchas variaciones sobre cómo aplicar qué mecanismo de cotización. Hacerlo a mano suele ser cuestión de práctica y experiencia. Al hacerlo de manera programática, generalmente es mejor elegir el más fácil de hacer bien (generalmente el "más literal" (el menor número de escapes)).
  4. Opcionalmente, use la cadena entre comillas resultante con código adicional.
  5. Si aún no ha alcanzado el nivel deseado de citación / interpretación, tome la cadena entre comillas resultante (más cualquier código agregado) y utilícela como cadena inicial en el paso 2.

La semántica de las citas varía

Lo que hay que tener en cuenta aquí es que cada idioma (nivel de comillas) puede dar una semántica ligeramente diferente (o incluso una semántica drásticamente diferente) al mismo carácter de comillas.

La mayoría de los idiomas tienen un mecanismo de citación "literal", pero varían exactamente en lo literal que son. La comilla simple de conchas tipo Bourne es en realidad literal (lo que significa que no puede usarla para citar un carácter de comilla simple). Otros lenguajes (Perl, Ruby) son menos literales en el sentido de que interpretan algunas secuencias de barra invertida dentro de regiones entre comillas simples de forma no literal (específicamente, \\ y \' dan como resultado \ y ' , pero otras secuencias de barra invertida son en realidad literales).

Deberá leer la documentación de cada uno de sus idiomas para comprender sus reglas de cotización y la sintaxis general.

Tu ejemplo

El nivel más interno de su ejemplo es un programa awk .

{print $1}

Vas a incrustar esto en una línea de comandos de shell:

pgrep -fl java | grep -i datanode | awk …

Necesitamos proteger (como mínimo) el espacio y el $ en el programa awk . La opción obvia es usar comillas simples en el shell alrededor de todo el programa.

  • '{print $1}'

Sin embargo, hay otras opciones:

  • {print\ \$1} escapa directamente del espacio y $
  • {print' $'1} comilla simple solo el espacio y $
  • "{print \$1}" comillas dos veces el todo y escapa del $
  • {print" $"1} comillas dobles solo el espacio y $
    Esto puede estar doblando un poco las reglas ( $ sin escape al final de una cadena entre comillas dobles es literal), pero parece funcionar en la mayoría de los shells.

Si el programa usó una coma entre las llaves abiertas y cerradas, también necesitaríamos citar o escapar de la coma o de las llaves para evitar la "expansión de llaves" en algunos shells.

Seleccionamos '{print $1}' y lo incrustamos en el resto del "código" del shell:

pgrep -fl java | grep -i datanode | awk '{print $1}'

A continuación, quería ejecutar esto a través de su y sudo .

sudo su user -c …

su user -c … es como some-shell -c … (excepto que se ejecuta bajo algún otro UID), por lo que su solo agrega otro nivel de shell. sudo no interpreta sus argumentos, por lo que no agrega ningún nivel de comillas.

Necesitamos otro nivel de shell para nuestra cadena de comandos. Podemos volver a elegir entre comillas simples, pero tenemos que dar un tratamiento especial a las comillas simples existentes. La forma habitual se ve así:

'pgrep -fl java | grep -i datanode | awk '\''{print $1}'\'

Aquí hay cuatro cadenas que el shell interpretará y concatenará: la primera cadena entre comillas simples ( pgrep … awk ), una comilla simple escapada, el programa awk entre comillas simples, otra comilla simple escapada.

Existen, por supuesto, muchas alternativas:

  • pgrep\ -fl\ java\ \|\ grep\ -i\ datanode\ \|\ awk\ \'{print\ \$1} escapar de todo lo importante
  • pgrep\ -fl\ java\|grep\ -i\ datanode\|awk\ \'{print\$1} igual, pero sin espacios en blanco superfluos (¡incluso en el programa awk !)
  • "pgrep -fl java | grep -i datanode | awk '{print \$1}'" comillas dobles todo, escapa del $
  • 'pgrep -fl java | grep -i datanode | awk '"'"'{print \$1}'"'" tu variación; un poco más de lo habitual debido al uso de comillas dobles (dos caracteres) en lugar de escapes (un carácter)

El uso de cotizaciones diferentes en el primer nivel permite otras variaciones en este nivel:

  • 'pgrep -fl java | grep -i datanode | awk "{print \$1}"'
  • 'pgrep -fl java | grep -i datanode | awk {print\ \$1}'

Incrustar la primera variación en la línea de comando sudo / * su * da esto:

sudo su user -c 'pgrep -fl java | grep -i datanode | awk '\''{print $1}'\'

Puede usar la misma cadena en cualquier otro contexto de nivel de shell único (por ejemplo, ssh host … ).

A continuación, agregó un nivel de ssh en la parte superior. Este es efectivamente otro nivel de shell: ssh no interpreta el comando en sí, pero lo entrega a un shell en el extremo remoto (a través de (por ejemplo) sh -c … ) y ese shell interpreta la cadena.

ssh host …

El proceso es el mismo: toma la cadena, elige un método de cotización, úsalo, incrustalo.

Usando comillas simples nuevamente:

'sudo su user -c '\''pgrep -fl java | grep -i datanode | awk '\'\\\'\''{print $1}'\'\\\'

Ahora hay once cadenas que se interpretan y concatenan: 'sudo su user -c ' , comillas simples de escape, 'pgrep … awk ' , comillas simples de escape, barra invertida de escape, dos comillas simples de escape, el programa awk entre comillas simples, un single de escape cita, una barra invertida de escape y una comilla simple de escape final.

La forma final se ve así:

ssh host 'sudo su user -c '\''pgrep -fl java | grep -i datanode | awk '\'\\\'\''{print $1}'\'\\\'

Esto es un poco difícil de escribir a mano, pero la naturaleza literal de la cita única del shell facilita la automatización de una ligera variación:

#!/bin/sh

sq() { # single quote for Bourne shell evaluation
    # Change ' to '\'' and wrap in single quotes.
    # If original starts/ends with a single quote, creates useless
    # (but harmless) '' at beginning/end of result.
    printf '%s\n' "$*" | sed -e "s/'/'\\\\''/g" -e 1s/^/\'/ -e \$s/\$/\'/
}

# Some shells (ksh, bash, zsh) can do something similar with %q, but
# the result may not be compatible with other shells (ksh uses $'...',
# but dash does not recognize it).
#
# sq() { printf %q "$*"; }

ap='{print $1}'
s1="pgrep -fl java | grep -i datanode | awk $(sq "$ap")"
s2="sudo su user -c $(sq "$s1")"

ssh host "$(sq "$s2")"

Leave a Comment

Your email address will not be published. Required fields are marked *

Scroll to Top

web tasarım