Editor VI.

Vi ha sido el primer editor de texto a pantalla completa para sistemas Unix . Además fue creado con la intención de que fuese sencillo en su uso y ligero para no cargar sobremanera el sistema. Para aquellos acostumbrados a usar editores de texto mediante en entornos gráficos, puede resultar un poco abrupto y complejo su aprendizaje, pero si bien porque estamos al cargo de un servidor Linux o porque nuestro entorno gráfico está dando problemas y no carga, deberíamos ser capaces de editar ficheros desde un editor como Vi / Vim.

Veamos los diferentes comandos básicos de movimiento, inserción y borrado (siempre en modo comando):

ComandoSignificado
hMover el cursor a la izquierda.
jMover el cursor hacia abajo.
kMover el cursor hacia arriba.
lMover el cursor hacia la derecha.
iInsertar texto en la posición actual del cursor (Insert), pasando a Modo Inserción. Se permanece en modo inserción hasta que se sale explícitamente de él.
ESCSalir del modo inserción y volver a modo comando. En modo comando, permite cancelar muchos de los comandos que se están ejecutando.
xBorrar el caracter bajo el cursor (equivale a la tecla Del/Supr).
XBorrar el caracter a la izquierda del cursor (equivale a la tecla Borrar/Backspace).
JJuntar la línea actual con la siguiente (Join), eliminando el retorno de carro entre ellas.
uDeshacer la última acción (Undo). Si lo pulsamos más veces desharemos acciones anteriores.
CTRL+RRehacer la última acción (Redo). Si lo pulsamos más veces reharemos acciones posteriores deshechas.
aInsertar texto en la siguiente posición tras el cursor (Append). Es similar a i, salvo que el texto no se inserta en la posición actual del cursor sino a su derecha.
APoner el cursor al final de la línea y pasar a modo inserción (añadir texto al final).
oCrear una línea vacía, en blanco, bajo la línea actual, y pasar a modo inserción con el cursor posicionado en dicha línea. Es mucho más cómodo que (como en otros editores) tener que pulsar FIN y ENTER para crear una línea en blanco.
OCrear una línea vacía, en blanco, sobre la línea actual. Sería el equivalente en otros editores a ARRIBA, ARRIBA, FIN, ENTER.
ddBorrar la línea actual (sobre la que está el cursor).
DBorrar desde la posición actual del cursor hasta el final de la línea.

En la mayoría de comandos de Vim podemos añadir counts, que es como se conoce a los repetidores del comando. El count es un número que se teclea antes del comando para que se repita varias veces. Unido a la potencia del modo comando nos da mucho juego para la edición. Veamos unos cuantos ejemplos:

ComandoSignificado
10ddRepetir 10 veces el comando dd, es decir borrar 10 líneas empezando desde la línea actual. Es el equivalente a teclear manualmente 10 veces dd, y mucho más rápido que seleccionar 10 líneas a mano con ratón o cursores.
5xRepetir 5 veces el comando x, es decir, borrar 5 caracteres empezando desde el carácter actual. Equivale a pulsar manualmente 5 veces el comando x.
60i-<ESC><ENTER>Insertar 60 guiones consecutivos. Este comando se teclea en modo comando pulsando 6, 0, i, guión, y pulsando la tecla ESCAPE y luego pulsar ENTER para validar el comando. Al hacerlo, estamos diciendo que se repita 60 veces la secuencia i guión ESCAPE, es decir, pasar a modo inserción, escribir un guión, y volver al modo comando pulsando ESCAPE. El 60 que hay delante lo repite 60 veces, con lo cual tenemos 60 guiones en pantalla. ¿No es mucho más cómodo al programar, para introducir separadores de comentarios, que pulsar el guión 60 veces o durante varios segundos mientras miramos la columna en la que estamos?
10iHola<ENTER><ESC><ENTER>(pulsar ESC y ENTER como las teclas ESC y ENTER, no tecleando la cadena) Aparece la palabra Hola 10 veces en pantalla, cada vez en una línea propia. Su significado, al igual que en el ejemplo anterior, sería repite 10 veces la secuencia i, Hola, ENTER, ESC, que pasa a modo inserción, escribe Hola, pasa a la siguiente línea con ENTER, y vuelve a modo comando.

Los comandos básicos a la hora de editar ficheros son:

ComandoSignificado
:wGrabar los cambios del fichero actual.
:w nombreGrabar el contenido actual del buffer en un fichero de nombre nombre.
:q!Salir del editor sin grabar ningún cambio en el fichero actual (descartando cualquier cosa que hayamos hecho desde su apertura o última vez que grabamos).
ZZSalir del editor grabando los cambios en el fichero actual. También sirve 😡 o :wq!.
CTRL+GObtener información en la barra de estado del nombre del fichero que estamos editando, línea actual, número de líneas, en qué porcentaje del fichero estamos, y número de columna.
:e ficheroAbrir un fichero en el buffer actual (si está vacío) o en uno nuevo (si tenemos el buffer actual en uso)

En el caso de que hayamos abierto con :e más de un fichero, podemos movernos entre ellos con:

ComandoSignificado
:bnSiguiente buffer (fichero).
:bpAnterior buffer (fichero).
:bdCerrar buffer (fichero) actual.

En Vim podemos aplicar las búsquedas, borrados y modificaciones no sólo a la línea actual o a la totalidad del documento, sino que también podemos hacer referencia a porciones del texto:

Rango definido con…Significado
%Todo el documento.
n,MBloque de líneas desde la n a la M.
‘a,’bBloque de líneas entre las marcas a y b.
‘<,’>Bloque de texto seleccionado en modo visual.

Por ejemplo:

:17,20d                -> Borrar líneas de la 17 a la 20

:’a,’b s/hola/adios/g  -> Cambiar cadena en el bloque entre las marcas ‘a y ‘b

Hemos dicho que con el modo comando de Vim tenemos muchas más opciones que con el modo inserción (o que en otros editores), pero hasta ahora sólo hemos visto una ínfima parte de las posibilidades de Vim. Como veremos ahora, no tenemos porqué movernos carácter a carácter, línea a línea o página a página. Vamos a poder movernos a la palabra anterior y la siguiente, a cualquier parte del fichero, etc.

ComandoSignificado
wMueve el cursor al principio de la siguiente palabra de la línea actual, o de la siguiente línea si estamos en la última palabra de la línea.
bMueve el cursor al principio de la anterior palabra de la línea actual, o de la anterior línea si estamos en la primera palabra de la línea.
eIgual que w, pero coloca el cursor en el último carácter de la siguiente palabra (al final de la palabra en lugar de al principio).
geIgual que b, pero coloca el cursor en el último carácter de la anterior palabra.
W, B, E y gEIguales que wbe y ge, pero con una peculiaridad. En mayúsculas, nos movemos de palabra en palabra considerando como separador de palabra sólo los espacios en blanco y retornos de carro, mientras que en minúsculas, Vim utiliza un modo inteligente con más separadores de palabras, como el guión o la barra. Por ejemplo, en el caso de tener la frase cadena1-cadena2 cadena3 o cadena1/cadena2 cadena3 con el cursor sobre el primer carácter, w avanzaría el cursor hasta primera letra de cadena2, mientras que W lo avanzaría hasta la primera letra de cadena3.
$Mueve el cursor al final de la línea (equivalente a la tecla Fin).
0Mueve el cursor al principio de la línea (equivalente a la tecla Inicio).
^Mueve el cursor al primer carácter no blanco de la línea. Perfecto a la hora de programar, cuando queremos corregir cosas en el código, normalmente indentado con espacios o tabuladores al principio de las líneas.
{Mueve el cursor al anterior párrafo (o bloque de código).
}Mueve el cursor al siguiente párrafo (o bloque de código).
f<carácter>Realiza una búsqueda en la línea actual del carácter indicado. Por ejemplo, fx mueve el cursor a la primera aparición del carácter x desde la posición actual. Muy útil para ir rápidamente a partes concretas de una línea sin llevar la mano al ratón (por ejemplo, para corregir una h que sea un error ortográfico, pulsando fh.
F<carácter>Igual que el comando anterior, pero realizando la búsqueda hacia atrás en la línea actual (empezando desde la posición actual del cursor).
t<carácter> y T<carácter>Similares a f<carácter> y F<carácter> salvo que posicionan el cursor en el carácter anterior a la letra buscada.
; y ,Repiten la ejecución del último comando f, F, t o T hacia adelante (;) o hacia atrás (,).
ESCEn el caso de búsquedas f, F, t o T, permite cancelar la búsqueda.
%Al pulsarlo sobre un paréntesis abierto o cerrado (, ), corchete abierto o cerrado [, ] , o llave abierta o cerrada {, }, mueve el cursor a la pareja de dicho elemento. Por ejemplo, si estamos programando y queremos saber cuál es el paréntesis que cierra el paréntesis sobre el cual está el cursor, pulsamos % y vim nos lleva directamente a él. Como también funciona con corchetes y llaves, podemos encontrar fácilmente qué llave cierra un bloque de código, o qué if/for/while/loquesea es el que ha abierto una determinada llave de cierre en un programa en C que estemos depurando.
<NUMERO>GIr a la línea número NUMERO del documento. Por ejemplo, 100G nos llevaría a la línea número 100. Es especialmente útil a la hora de programar, cuando tenemos que ir a líneas concretas del programa donde el compilador nos ha reportado errores.

Si no estamos programando pero queremos utilizar números de líneas (porque nos parece más cómodo), podemos hacer uso de las siguientes opciones de modo comando:

ComandoSignificado
:set numberActiva la numeración de líneas.
:set nonumberDesactiva la numeración de líneas.
:set rulerActiva en la barra de estado una indicación de la columna y fila actual.

Cualquiera de estas opciones las podemos poner en nuestro fichero .vimrc para que se apliquen a todos los documentos que editemos, o cambiarlas en cualquier momento en modo comando.

ComandoSignificado
ggIr a la primera línea del documento (equivale a 1G)
GSin número delante, G nos lleva a la última línea del documento.
<NUMERO>%Nos lleva a un porcentaje concreto del fichero. Por ejemplo 50% nos lleva a la mitad del fichero, y 95%, casi al final del mismo.
CTRL+FScrollea una pantalla completa hacia adelanta (F de Forward).
CTRL+BScrollea una pantalla completa hacia atrás (B de Backward).
CTRL+EScrollea la pantalla en una sóla línea hacia arriba.
CTRL+YScrollea la pantalla en una sóla línea hacia abajo.
CTRL+UScrollea media pantalla de texto hacia abajo (el equivalente a hacer medio RePág). Puede sonar raro el hecho de scrollear medias pantallas, pero en determinadas situaciones puede ser útil (si no queremos perder de vista texto ya leído cuando avanzamos, por ejemplo).
CTRL+DScrollea media pantalla de texto hacia arriba (como hacer medio AvPág). Permite así avanzar el documento media página sin perder de vista el texto donde está el cursor.
zzSin modificar la posición actual del cursor, modifica la ventana de visualización del fichero de forma que la línea actual acabe centrada en pantalla y podamos ver el contexto. Por ejemplo, supongamos que estamos en la parte de abajo de la pantalla con el cursor en la última línea y necesitamos ver con facilidad y claridad qué líneas hay sobre y bajo ella. En otros editores usaríamos la tecla de Abajo hasta centrar un poco la línea en pantalla y luego subiríamos hacia arriba para volver a la línea en que estábamos. En Vim basta con pulsar zz para centrar la línea actual en pantalla sin mover la posición del cursor para nada.
ztIgual que zz pero posicionando la línea en la parte superior de la pantalla (t viene de top) lo que nos permite ver con claridad la línea actual y muchas líneas posteriores.
zbIgual que zt, pero posicionando la línea en la última posición de la ventana de pantalla, lo que nos permite ver la línea actual y muchas líneas anteriores. En ambos 3 comandos no se modifica la posición del cursor en el documento, sólo la manera de verlo en pantalla.

De nuevo podemos utilizar multiplicadores en todos los comandos anteriores para evitarnos pulsaciones innecesarias de teclas:

ComandoSignificado
20wAvanzar 20 palabras.
3fxAvanzar el cursor a la tercera aparición de la letra x en la línea actual, desde la posición del cursor.

Por último, respecto a comandos de movimiento, existen 3 comandos muy especiales que nos permiten posicionar el cursor al principio, medio y final de la pantalla. Ojo, no principio, medio y final del fichero, sino de la pantalla, de lo que vemos en nuestro monitor:

ComandoSignificado
HPosiciona el cursor al principio de la pantalla (sin hacer scroll de ella).
MPosiciona el cursor en el centro de la pantalla.
LPosiciona el cursor en la parte baja de la pantalla.
ComandoSignificado
4dwRepetir 4 veces dw, es decir, borrar 4 palabras.
d4wBorrar el resultado de 4w, es decir, borrar el resultado de moverse 4 palabras.

Como algunos modificaciones y operadores se utilizan tanto, Vim nos proporciona unos atajos de una sola letra para ejecutarlos:

AtajoEquivalenteSignificado
xdlBorrar el carácter bajo el cursor.
XdhBorrar el carácter a la izquierda del cursor.
Dd$Borrar hasta el final de la línea.
Cc$Cambiar el texto hasta el final de la línea.
sclCambiar un carácter.
SccCambiar la línea completa.

Gracias a la potencia de Vim, entre operadores y multiplicadores podemos hacer la edición muchísimo más rápida. Veamos algunos comandos más avanzados:

ComandoSignificado
dwBorrar desde el cursor hasta el final de la palabra actual. Por ejemplo, si estamos encima de la letra m de la palabra automóvil, ejecutando dw quedaría tan sólo la palabra auto. Recuerda que w avanza hasta el siguiente separador de palabra y W hasta el siguiente espacio entre palabras, de modo que también podemos usar dW si es lo que nos interesa.
dbBorrar desde el cursor hasta el principio de la palabra actual. Por ejemplo, si estamos encima de la letra m de la palabra automóvil, ejecutando db quedaría tan sólo la palabra móvil.
diwBorrar la palabra bajo el cursor (completa), desde su principio hasta su final, estemos donde estemos dentro de la palabra.
dawBorrar la palabra bajo el cursor, igual que diw, pero en este caso si existe un espacio tras la palabra también lo borra.
disBorrar la frase (no línea, sino frase hasta el próximo punto) sobre la que está el cursor.
dasIgual que dis, pero si existe un espacio tras la frase también lo elimina.
dGBorrar desde la posición actual del cursor hasta el final del fichero.
dggBorrar desde la posición actual del cursor hasta el principio del fichero.

Otra de las operaciones básicas de búsqueda es el reemplazo de cadenas, es decir, cambiar en todo el fichero (o en una parte del mismo) una cadena por otra. Esto se hace con el comando de sustitución :s.

Por ejemplo, para cambiar todas las apariciones de la cadena hola por adios, haremos:

:%s/hola/adios/g 

Este comando viene a decirle a Vim que sustituya (s), en todo el fichero (%), la cadena hola por adios, y que si en una línea encuentra más de una aparición de hola, que cambie todas (g). Si quitamos la g, sólo cambiaremos la primera aparición de hola en cada frase. Si además de la g añadimos una i, se hará una comparación que no distingue mayúsculas de minúsculas.

Recordad que en el caso de usar expresiones regulares tendremos que escapar ciertos caracteres especiales, como los puntos, las barras, etc, en la parte de búsqueda. Por ejemplo:

:%s/hola\.hola/adios.adios/g 

El resumen del uso básico de la sustitución en Vim es:

ComandoSignificado
:%s/cad1/cad2/Reemplazar en cada línea del fichero la primera aparición de cad1 (sea cadena o expresión regular) por cad2.
:%s/cad1/cad2/gReemplazar en cada línea del fichero todas las apariciones de cad1 por cad2.
:%s/cad1/cad2/giReemplazar en cada línea del fichero todas las apariciones de cad1 por cad2, sin distinguir mayúsculas y minúsculas
:%s/cad1/cad2/gcReemplazar en cada línea del fichero todas las apariciones de cad1 por cad2
pidiendo confirmación en cada reemplazo.
:%s/cad\(regexp\)ena/cad\1ena2/gcUtilizar en la sustitución parte de la búsqueda por expresión regular
:n,NcomandoCualquiera de los 3 ejemplos anteriores, sobre un rango de líneas.
:'<,’>comandoCualquiera de los ejemplos anteriores, sobre la selección «visual» actual.
‘<,’> aparece cuando tenemos un texto seleccionado y pulsamos «:».
:’a,’bs/cad1/cad2/gRealizar la sustitución en el texto entre 2 marcas (a y b en el ejemplo).
:%s//CAD2/gReutilizar la última búsqueda realizada para el reemplazo (búsqueda vacía en %s)

A continuación mostramos una serie de ejemplos basicos útiles que no tienen cabida en otra sección pero que pueden resultar interesantes si el lector no los ha deducido ya para realizar una tarea concreta:

  • :%s/*$/ → Eliminar espacios en blanco al final de línea en todo el documento.
  • :%s/TABULADOR*$// → Eliminar espacios en blanco y tabuladores al final de línea en todo el documento.
  • :g/cadena/d → Eliminar todas aquellas líneas que contienen una cadena o patrón.
  • :g/^ *#/d → Eliminar todas las líneas de comentarios de python (que desde el principo de línea haya 0 o más espacios y una almohadilla). Aplicación del ejemplo anterior.
  • :g!/cadena/d → Eliminar todas aquellas líneas que no cumplen un patrón indicado.
  • :1,$ s/^V^M// → Eliminar retornos de carro de MSDOS (las teclas ^V y ^M se corresponden con Ctrl+V y Ctrl+M y hay que pulsarlas primero una y después la otra, no teclear su texto).
Publicado en Unix - Linux | Deja un comentario

LINUX – Comando TR – Ejemplos para aprender el uso.

En el caso que tengamos un texto y queramos transformar la totalidad de a a A lo haremos del siguiente modo:

echo "Esto es una ejemplo de tr para el blog geekland" | tr 'a' 'A'

En el caso que queramos reemplazar todas las vocales de una frase de minúscula a mayúscula lo podemos hacer del siguiente modo:

echo "Esto es una ejemplo de tr para el blog geekland" | tr 'aeiou' 'AEIOU'

En el caso que queramos transformar la totalidad de letras mayúsculas a minúsculas lo podemos hacer del siguiente modo:

echo "Esto es una ejemplo de tr para el blog geekland" | tr 'a-z' 'A-Z' > geekland.txt

Si queremos también podemos añadir una línea nueva al fichero geekland.txt que sea igual que la primera pero en minúscula siguiendo el siguiente procedimiento:

cat geekland.txt | tr 'A-Z' 'a-z' >> geekland.txt 

Si ejecutamos el siguiente comando:

echo "Esto es un ejemplo de tr para el blog geekland" | tr 'a-z' 'AB'

Vemos que ha ocurrido lo siguiente:

La letra a se reemplaza por la A. La b por la B y a partir de aquí la cef… hasta llegar la z se reemplazarán por la B.

Si queremos evitar este comportamiento podemos usar la opción -t o truncate. Si ejecutamos el mismo comando añadiendo la opción -t:

echo "Esto es un ejemplo de tr para el blog geekland" | tr -t 'a-z' 'AB'

Vemos que ha ocurrido lo siguiente:

La letra a se reemplaza por la A. La b por la B y a partir de aquí no se reemplazará ninguna otra letra. El comportamiento ahora será de este modo gracias a la opción -t. Por lo tanto la opción -t hace que la longitud del primero de los argumentos introducidos en el comando tr sea igual que la del segundo argumento.

Nota: Con la opción -t el primero de los argumentos introducidos del comando tr tiene que tener una longitud igual o superior al segundo de los argumentos.

Si queremos borrar todas las vocales mayúsculas y minúsculas de una frase y que sean reemplazadas por un espacio en blanco lo haremos mediante la opción tr -d. Un ejemplo de lo que acabo de citar es el siguiente:

echo "Esto es un ejemplo de tr para el blog geekland" | tr -d 'aeiou' | tr -d 'AEIOU'

Si quisiéramos que las vocales borradas fueran reemplazadas por espacios en blanco deberíamos haber usado el siguiente comando:

echo "Esto es un ejemplo de tr para el blog geekland" | tr 'aeiou' ' '

Para borrar todo el contenido de una frase excepto las vocales aeiou, tendremos que usar la opción -c. La opción -c o complemento vendría a actuar como lo contrario a la orden que introducimos en el comando. Por lo tanto para borrar todas las letras que no sea vocales de una frase lo haremos del siguiente modo:

echo "Esto es un ejemplo de tr para el blog geekland" | tr -cd 'aeiou'

Para borra todos los caracteres que no son legibles, se utiliza el siguiente comando :

head /dev/urandom | tr -cd '[:print:]\n'

Nota: Mediante la opción -cd '[:print:]' estamos diciendo que se borre todo carácter que no se imprimible/legíble. Además la opción \n hará que al finalizar la tarea el cursos de la terminal quede ubicado en una nueva línea.

Para borra todo lo que no sea un digito o numero se realizara con el siguiente comando :

echo "Esto es un ejemplo de tr para el blog gee1kland 1234" | tr -cd '[:digit:]\n'

Si por lo contrario quieren borrar la totalidad de números que aparecen a la frase tan solo tendrían que eliminar la opción -c complemento y obtendrían el siguiente resultado:

echo "Esto es un ejemplo de tr para el blog gee1kland 1234" | tr -d '[:digit:]\n'

En ocasiones escribimos rápido y es posible que por error escribamos 2 caracteres repetidos de forma consecutiva. Un ejemplo de lo que acabo de citar es el siguiente:

Esto es un ejeeemplo de tr para el blog.

En el ejemplo vemos que a la palabra ejemplo le sobran dos e. Para eliminarlas lo podemos hacer con la opción -s Squeeze del siguiente modo:

echo "Esto es un ejeeemplo de tr para el blog geekland" | tr -s 'e'

Si tuviéramos una frase con exceso de espacios, como por ejemplo la siguiente:

El comando    tr  es       útil                   en determinados               casos

Y quisiéramos eliminar los espacios sobrantes lo haríamos del siguiente modo:

echo "El comando    tr  es       útil   en determinados casos" | tr -s [:space:]

Transformar los espacios en tabulaciones horizontales o verticales con TR

En el ejemplo que propondremos a continuación tenemos 3 palabras separadas por un espacio:

joan carles geekland

Si queremos transformar este espacio por un tabulación lo haremos usando la opción [:space:] y \t del siguiente modo:

echo "joan carles geekland" | tr [:space:] '\t'

La opción \t añade una tabulación horizontal. Si quisiéramos añadir una tabulación vertical lo haríamos con la opción \v del siguiente modo obteniendo un resultado parecido al siguiente:

echo "joan carles geekland" | tr [:space:] '\v'

Generar una nueva línea cada vez que encontremos un determinado carácter delimitador

Si tenemos una frase, que obviamente está compuesta por palabras separadas por espacio, podemos separar cada una de las palabras en una nueva línea usando la siguiente sintaxis:

echo "joan carles geekland" | tr [:space:] '\n'

Obviamente este artículo únicamente detalla algunas de las opciones del comando tr.

Publicado en Unix - Linux | Deja un comentario

Lenguaje programación AWK.

Articulo obtenido desde la siguiente página : «https://learnxinyminutes.com/docs/es-es/awk-es/».

Usando el buscador, puedes obtener más códigos útiles del lenguaje AWK..

AWK es una herramienta estándar en cada sistema UNIX compatible con POSIX. Es como un Perl restringido, perfecto para tareas de procesamiento de texto y otras necesidades de scripting. Tiene una sintaxis similar a C, pero sin puntos y comas, manejo manual de memoria y tipado estático. Puedes llamarlo desde un script de shell o usarlo como un lenguaje stand-alone para scripting.

¿Por qué elegir AWK sobre Perl? Principalmente, porque AWK es parte de UNIX. Siempre puedes contar con él, mientras que el futuro de Perl está en duda. AWK es más fácil de leer que Perl. Para scripts sencillos de procesamiento de texto, particularmente si es para leer archivos línea a línea y dividir por delimitadores, probablemente AWK es la herramienta correcta para el trabajo.

#!/usr/bin/awk -f
# Los comentarios tienen este aspecto.
# Los programas AWK son una colección de patrones y acciones. El patrón más
# importante es BEGIN. Las acciones van en bloques delimitados por llaves.
BEGIN {
    # BEGIN correrá al inicio del programa. Es donde pones todo el código
    # preliminar antes de procesar los archivos de texto. Si no tienes archivos
    # de texto, piensa en BEGIN como el punto de entrada principal del script.
    # Las variables son globales. Asígnalas o úsalas sin declararlas.
    count = 0
    # Los operadores son justo como en C (y amigos).
    a = count + 1
    b = count - 1
    c = count * 1
    d = count / 1
    e = count % 1 # módulo
    f = count ^ 1 # exponenciación
    a += 1
    b -= 1
    c *= 1
    d /= 1
    e %= 1
    f ^= 1
    # Incremento y decremento en uno
    a++
    b--
    # Como un operador prefijo, regresa el valor modificado
    ++a
    --b
    # Nota que no hay puntación para terminar las instrucciones
    # Instrucciones de control
    if (count == 0)
        print "Iniciando count en 0"
    else
        print "Eh?"
    # O puedes usar el operador ternario
    print (count == 0) ? "Iniciando count en 0" : "Eh?"

    # Bloques formados por múltiples líneas usan llaves
    while (a < 10) {
        print "La concatenación de strings se hace " " con series " 
	print " de" " strings separados por espacios"
        print a
        a++
    }
    for (i = 0; i < 10; i++)
        print "El viejo confiable ciclo for"
    # Los operaciones de comparación son estándar...
    a < b   # Menor que
    a <= b  # Menor o igual que
    a != b  # No igual
    a == b  # Igual
    a > b   # Mayor que
    a >= b  # Mayor o igual que
    # ...así como los operadores lógicos
    a && b  # AND
    a || b  # OR
    # Además están las expresiones regulares
    if ("foo" ~ "^fo+$")
        print "Fooey!"
    if ("boo" !~ "^fo+$")
        print "Boo!"
    # Arrays
    arr[0] = "foo"
    arr[1] = "bar"
    # Desafortunadamente no hay otra manera de inicializar un array.
    # Tienes que inicializar cada posición del array.
    # También hay arrays asociativos
    assoc["foo"] = "bar"
    assoc["bar"] = "baz"
    # Y arrays multidimensionales con limitaciones que no mencionaré aquí
    multidim[0,0] = "foo"
    multidim[0,1] = "bar"
    multidim[1,0] = "baz"
    multidim[1,1] = "boo"
    # Puedes probar pertenencia a un array
    if ("foo" in assoc)
        print "Fooey!"
    # También puedes usar el operador 'in' para iterar las claves de un array
    for (key in assoc)
        print assoc[key]
    # La terminal es un array especial llamado ARGV
    for (argnum in ARGV)
        print ARGV[argnum]
    # Puedes eliminar elementos de un array.
    # Esto es útil para prevenir que AWK suponga que algunos argumentos
    # son archivos por procesar.
    delete ARGV[1]
    # El número de argumentos de la terminal está en la variable ARGC
    print ARGC
    # AWK tiene tres categorías de funciones incluidas.
    # Demostraré esas funciones posteriormente.
    return_value = arithmetic_functions(a, b, c)
    string_functions()
    io_functions()
}
# Así se define una función
function arithmetic_functions(a, b, c,     localvar) {
    # Probablemente la parte más molesta de AWK es que no hay variables locales
    # Todo es global. No es problema en scripts pequeños, pero sí para
    # scripts más grandes.

    # Hay un work-around (mmm... hack). Los argumentos de las funciones son 
    # locales para la función, y AWK permite definir más argumentos de función
    # de los que necesita, por lo que define las variables locales en la 
    # declaración como en la función de arriba. Como convención, agrega
    # espacios en blanco para distinguir los parámetros de la función de las 
    # variables locales. En este ejemplo, a, b y c son parámetros y localvar es una 
    # variable local.
    # Ahora, a demostrar las funciones aritméticas
    # La mayoría de las implementaciones de AWK tienen funciones
    # trigonométricas estándar
    localvar = sin(a)
    localvar = cos(a)
    localvar = atan2(b, a) # arcotangente de b / a
    # Y cosas logarítmicas
    localvar = exp(a)
    localvar = log(a)
    # Raíz cuadrada
    localvar = sqrt(a)
    # Trucar un flotante a entero
    localvar = int(5.34) # localvar => 5
    # Números aleatorios
    srand() # La semilla es el argumento. Por defecto usa el tiempo del sistema
    localvar = rand() # Número aleatorio entre 0 y 1.
    # Y aquí se regresa el valor
    return localvar
}
function string_functions(    localvar, arr) {
    # AWK tiene algunas funciones para procesamiento de strings,
    # y muchas dependen fuertemente en expresiones regulares.
    # Buscar y remplazar, primer instancia (sub) o todas las instancias (gsub)
    # Ambas regresan el número de matches remplazados.
    localvar = "fooooobar"
    sub("fo+", "Meet me at the ", localvar) # localvar => "Meet me at the bar"
    gsub("e", ".", localvar) # localvar => "m..t m. at th. bar"
    # Buscar una cadena que haga match con una expresión regular
    # index() hace lo mismo, pero no permite expresiones regulares
    match(localvar, "t") # => 4, dado que 't' es el cuarto caracter
    # Separar con base en un delimitador
    split("foo-bar-baz", arr, "-") # a => ["foo", "bar", "baz"]
    # Otras funciones útiles
    sprintf("%s %d %d %d", "Testing", 1, 2, 3) # => "Testing 1 2 3"
    substr("foobar", 2, 3) # => "oob"
    substr("foobar", 4) # => "bar"
    length("foo") # => 3
    tolower("FOO") # => "foo"
    toupper("foo") # => "FOO"
}
function io_functions(    localvar) {
    # Ya has visto print
    print "Hello world"
    # También hay printf
    printf("%s %d %d %d\n", "Testing", 1, 2, 3)
    # AWK no tiene handles de archivos en sí mismo. Automáticamente abrirá un 
    # handle de archivo cuando use algo que necesite uno. El string que usaste 
    # para esto puede ser tratada como un handle de archivo para propósitos de I/O.
    # Esto lo hace similar al scripting de shell:
    print "foobar" >"/tmp/foobar.txt"
    # Ahora el string "/tmp/foobar.txt" es un handle. Puedes cerrarlo:
    close("/tmp/foobar.txt")
    # Aquí está como correr algo en el shell
    system("echo foobar") # => muestra foobar
    # Lee una línea de la entrada estándar (stdin) y lo guarda en localvar
    getline localvar
    # Lee una línea desde un pipe
    "echo foobar" | getline localvar # localvar => "foobar"
    close("echo foobar")
    # Lee una línea desde un archivo y la guarda en localvar
    getline localvar <"/tmp/foobar.txt"
    close("/tmp/foobar.txt")
}
# Como dije al inicio, los programas en AWK son una colección de patrones y 
# acciones. Ya conociste el patrón BEGIN. otros patrones sólo se usan si estás
# procesando líneas desde archivos o stdin.
# Cuando pasas argumentos a AWK, son tratados como nombres de archivos a 
# procesar. Los va a procesar todos, en orden. Imagínalos como un ciclo for 
# implícito, iterando sobre las líneas de estos archivos. Estos patrones y
# acciones son como instrucciones switch dentro del ciclo.
/^fo+bar$/ {
    # Esta acción se ejecutará por cada línea que haga match con la expresión
    # regular /^fo+bar$/, y será saltada por cualquier línea que no haga match.
    # Vamos a sólo mostrar la línea:
    print
    # ¡Wow, sin argumento! Eso es porque print tiene uno por defecto: $0.
    # $0 es el nombre de la línea actual que se está procesando.
    # Se crea automáticamente para ti.
    # Probablemente puedas adivinar que hay otras variables $. Cada línea es 
    # separada implícitamente antes de que se llame cada acción, justo como lo
    # hace shell. Y, como shell, cada campo puede ser accesado con $.
    # Esto mostrará el segundo y cuarto campos de la línea
    print $2, $4
    # AWK automáticamente define muchas otras variables que te ayudan a
    # inspeccionar y procesar cada línea. La más importante es NF
    # Imprime el número de campos de esta línea
    print NF
    # Imprime el último campo de esta línea
    print $NF
}
# Cada patrón es realmente un prueba de verdadero/falso. La expresión regular
# en el último patrón también es una prueba verdadero/falso, pero parte de eso
# estaba oculto. Si no le das un string a la prueba, supondrá $0, la línea que
# se está procesando. La versión completa de esto es:
$0 ~ /^fo+bar$/ {
    print "Equivalente al último patrón"
}
a > 0 {
    # Esto se ejecutará una vez por línea, mientras a sea positivo
}
# Y ya te das una idea. Procesar archivos de texto, leyendo una línea a la vez,
# y haciendo algo con ella, particularmente separando en un deliminator, es tan
# común en UNIX que AWK es un lenguaje de scripting que hace todo eso por ti
# sin que tengas que pedirlo. Basta con escribir los patrones y acciones 
# basados en lo que esperas de la entrada y lo quieras quieras hacer con ella.

# Aquí está un ejemplo de un script simple, para lo que AWK es perfecto.
# El script lee un nombre de stdin y muestra el promedio de edad para todos los
# que tengan ese nombre. Digamos que como argumento pasamos el nombre de un
# archivo con este contenido:
#
# Bob Jones 32
# Jane Doe 22
# Steve Stevens 83
# Bob Smith 29
# Bob Barker 72
#
# Éste es el script:
BEGIN {
    # Primero, pedir al usuario el nombre
    print "¿Para qué nombre quieres el promedio de edad?"
    # Recuperar una línea de stdin, no de archivos en la línea de comandos
    getline name <"/dev/stdin"
}
# Ahora, hacer match con cada línea cuyo primer campo es el nombre dado
$1 == name {
    # Aquí dentro tenemos acceso a variables útiles precargadas:
    # $0 es toda la línea
    # $3 es el tercer campo, la edad, que es lo que nos interesa
    # NF es el número de campos, que debe ser 3
    # NR es el número de registros (líneas) vistos hasta ahora
    # FILENAME es el nombre del archivo que está siendo procesado
    # FS es el campo separador, " " en este caso
    # Y muchas más que puedes conocer ejecutando 'man awk' en la terminal.

    # Llevar el registro de la suma y cuantas líneas han hecho match.
    sum += $3
    nlines++
}
# Otro patrón especial es END. Va a ejecutarse después de procesar todos los 
# archivos de texto. A diferencia de BEGIN, sólo se ejecuta si le das dado una
# entrada a procesar. Se ejecutará después de que todos los archivos hayan sido
# leídos y procesados según las reglas y acciones que programaste. El propósito
# es usualmente para mostrar un reporte final, o hacer algo con el agregado de
# los datos que has acumulado durante la ejecución del script.
END {
    if (nlines)
        print "La edad promedio para " name " es " sum / nlines
}
Publicado en Unix - Linux | Deja un comentario

LINUX – Poniendo color a nuestros SCRIPTS.

También existe la posibilidad de darle un toque más visual a aquello que imprimimos por pantalla; eso se logra mediante la inclusión de Etiquetas de color y mediante el mostrado de la cadena mediante el comando echo -e «cadena». Una etiqueta de color siempre tiene que ser almacenada en una variable y tienen que tener la siguiente estructura:

variable='\e[${codigo_color}m'

Los colores que se quieren especificar poseen un código númerico en concreto; es decir no se puede especificar un color como Rojo, negro, etc… Se tratan de códigos algo complejos de memorizar, es por ello que os listo a continuación cada color con su correspondiente código:

Negro             --> 0;30 
Gris oscuro   --> 1;30
Gris claro      --> 0;37
Azul               --> 0;34 
Azul claro     --> 1;34
Verde            --> 0;32 
Verde claro  --> 1;32
Cyan             --> 0;36 
Cyan claro   --> 1;36
Rojo              --> 0;31 
Rojo claro     --> 1;31
Morado          --> 0;35 
Morado claro --> 1;35
Marrón           --> 0;33 
Amarillo          -->1;33 
Blanco            --> 1;37
No color         --> 0

Queremos mostrar esta cadena con diferentes colores; para ello crearemos cuatro variables llamadas ROJO, CYAN, VERDE y BLANCO y haremos que la palabra vamos se muestre en rojo, las palabras a probar se muestren en cyan, la palabra diferentes se muestre en verde y por último la palabra colores se muestre en blanco.El código para lograr dicho sería el siguiente:

#!/bin/bash
###COMENZAMOS CREANDO VARIABLES CON COLORES###
ROJO='\e[0;31m'
CYAN='\e[0;36m'
VERDE='\e[0;32m'
BLANCO='\e[1;37m'
#PASAMOS A MOSTRAR EL TEXTO CON COLORES. MUY IMPORTANTE HACER ECHO CON EL PARAMETRO -e
echo -e "${ROJO}Vamos ${CYAN}a probar ${VERDE}diferentes ${BLANCO}colores"
Publicado en Unix - Linux | Deja un comentario

BASH -Script verificar correcta ejecución.-

El siguiente script intenta crear un subdirectorio tmp/project en el directorio actual. En la condición de la sentencia if verificamos si el valor de la variable $? es diferente de 0. Si ese es el caso, imprimimos un mensaje de error y salimos del script con el código de salida 1. La rama else imprime un mensaje exitoso y se ejecuta solo si el valor de $? es 0

#!/bin/bash
  
mkdir tmp/project

if [[ $? -ne 0 ]] ; then
    echo "Unable to create directory tmp/project"
    exit 1
else
    echo "Directory tmp/project created successfully"
fi
Publicado en Unix - Linux | Deja un comentario

BASH – LINUX ver fecha de caducidad de un certificado SSL (Plugin NAGIOS para renovar certificado SSL).-

Para la correcta ejecución debe tener instalado OPENSSL . El SCRIPT solicita 4 argumentos para su ejecución :

1 = Nombre servidor 2=Puerto 3=Días WARNING 4=Días CRITICAL

#!/bin/bash
servidor=$1
puerto=$2
warning=$3
critical=$4
hasta=`echo | openssl s_client -connect $servidor.dominio.cl:$puerto 2>/dev/null | openssl x509 -noout -dates | cut -d "=" -f2 | awk 'NR==2{print $0}'`
vence=`date -d "$hasta" +%Y%m%d`
START=`date -d $(date +"%Y%m%d") +%s`
END=`date -d $vence +%s`
((dife=$END-$START))
((dias=$dife/(60*60*24)))
if [ "$dias" -le "$warning" ] && [ "$dias" -ge "$critical" ]; then
     echo "WARNING - Quedan $dias para VENCER"
     exit 1
elif [ "$dias" -le "$critical" ]; then
     echo "CRITICAL - Quedan $dias para VENCER"
     exit 2
else
     echo "OK - Quedan $dias para VENCER"
     exit 0
fi
echo "UNKNOWN - Error Interno"
     exir 

Para ejecutarlo se debe dar permisos de ejecución :

chmod u+x check_cert.sh

Para ejecutarlo :

./check_cert.sh volcan01 443 20 10

Se obtiene el siguiente resultado :

OK – Quedan 129 días para VENCER

Publicado en Unix - Linux | Deja un comentario

BASH – Plugin NAGIOS memoria servidores AIX.

El SCRIPT solicita el valor WARNING y CRITICO del uso de memoria. Pasando estos umbrales, reportara en la consola NAGIOS según corresponda :

#!/bin/bash
# PORCENTAJES EJEMPLO 95 WARNING Y 98 CRITICAL
warning=$1
critical=$2
if [ -z "$critical" ] || [ -z "$warning" ]; then
   echo "UNKNOWN"
   exit 3
fi
# MEMORIA TOTAL USADA
um=`svmon -G | head -2|tail -1| awk {'print $3'}`
um=`expr $um / 256`
# MEMORIA TOTAL
tm=`lsattr -El sys0 -a realmem | awk {'print $2'}`
tm=`expr $tm / 1024`
# MEMORIA LIBRE Y PORCENTAJE
fm=`expr $tm - $um`
pt=`echo "scale=2;  $fm/$tm" | bc`
ps=`echo "scale=2;  $pt * 100" | bc`
# PORCENTAJE DE MEMORIA USADA
pa=`echo "scale=2;  $um/$tm" | bc`
pr=`echo "scale=2;  $pa * 100" | bc`
porusado=$pr
if [ "$porusado" -gt "$warning" ] && [ "$porusado" -lt "$critical" ]; then
     echo "WARNING - USADO $porusado% ${um}MB FREE $ps% ${fm}MB"
     exit 1
elif [ "$porusado" -ge "$critical" ]; then
     echo "CRITICAL - USADO $porusado% ${um}MB FREE $ps% ${fm}MB"
     exit 2
else
     echo "OK - USADO $porusado% ${um}MB FREE $ps% ${fm}MB"
     exit 0
fi

Publicado en Unix - Linux | Deja un comentario

BASH – Uso del comando «seq».-

Corresponde a herramienta de la línea de comandos. Sencilla, pero que combinada con otros comandos, puede ser de gran ayuda. Básicamente se encarga de imprimir una secuencia de números. Los siguientes comandos se pueden probar para ver lo que realizan :

seq 10                                               
   # Muestra del 1 al 10
seq 7 15                                             
   # Muestra del 7 al 15
seq 1 2 15                                           
   # Muestra del 1 al 15 saltándose de a 2  (1 3 5 .. 15)
seq -s, 1 9                                           
   # Se puede añadir un separador (1,2,3,4,5,6,7,8,9)
seq -f "%03g" 6                               
  # Se puede especificar un formato (001 002 .. 006)
expr `seq -s " + " 111 200`            
   # Muestra la suma desde el número 111 al 200 (13995)
echo $(seq -f "file%02g" 1 10)       
   # Muestra en pantalla file01 file02 file03 .. file10
touch $(seq -f "file%02g" 1 10)     
   # Igual que el anterior, pero aquí creara 10 archivos
Publicado en Unix - Linux | Deja un comentario

BASH – Operaciones y comparación de números con decimales en Scripts BASH.

En BASH no es posible ( de manera nativa) realizar operaciones con números decimales.  Para superar esta limitación de BASH, se utiliza el comando “bc”, con el cual se pueden realizar operaciones con números decimales, también se puede indicar la cantidad de números decimales que entregara en el resultado. Algunos ejemplos de código :

#!/bin/bash
# Cantidad de números pasados como argumentos
CANT_ARGUMENTOS=$#
# Separador de argumentos
IFS='+'
# Reunimos todos los argumentos incluyendo el separador
SUMA=$(echo "$(( $* ))")
# Calculamos el promedio
PROMEDIO=$(echo "scale=2; $SUMA/$CANT_ARGUMENTOS" | bc)
#Mostramos el mensaje por pantalla
echo "El promedio de los números ingresados es $PROMEDIO"

Otros ejemplos de linea de comandos :
echo "scale=4; 20/3" | bc -l
6.6666

Acá ingresaremos 2 valores, los cuales pueden ser positivos, negativo o decimal. El programa los valida que realmente correspondan a un número. Posterior a esto despliega el número menor ingresado :

#!/bin/bash
val1=$1
val2=$2
re='^[+-]?[0-9]+([.][0-9]+)?$'
if ! [[ $val1 =~ $re ]] || ! [[ $val2 =~ $re ]] ; then
   echo "error: Solo se aceptan numeros"
   exit
fi
min=$(echo $val1 $val2 | awk '{if ($1 < $2) print $1; else print $2}')
echo ""
echo "Valor minimo ingresado = $min"
exit

Ahora mostraremos la comparación de números decimales, para realizar esto, lo haremos con ayuda del lenguaje AWK (script adaptado para NAGIOS) , chequeo de UPTIME, el SCRIPT solicita se ingrese el WARNING y CRITICO de proceso y lo compara con el primer valor (Carga del sistema al minuto) :

#!/bin/bash
warning=$1
critical=$2
VARIABLE=`uptime`
IFS=',' read -ra datos <<< "$VARIABLE"
a=`echo "${datos[3]}" | cut -d ":" -f2`; b="${datos[4]}"; c="${datos[5]}"
up=`echo $a$b$c`
re='^[+]?[0-9]+([.][0-9]+)?$'
if ! [[ $warning =~ $re ]] || ! [[ $critical =~ $re ]] ; then
   echo "UNKNOWN - Load Average $up"
   exit 3
fi
if (( $(echo $a $warning $critical | awk '{if ($1 >= $2 && $1 < $3) print 1;}') )); then
     echo -e "WARNING - Load Average $up"
     exit 1
elif (( $(echo $a $critical | awk '{if ($1 >= $2) print 1;}') )); then
     echo -e "CRITICAL - Load Average $up"
     exit 2
else
     echo "OK - Load Average $up"
     exit 0
fi
AL EJECUTAR EL SCRIPT, MOSTRARIA ALGO COMO :

bash check_uptime.sh 20 50

WARNING  - Load Average  35.20  45.30  48.30

Publicado en Unix - Linux | Deja un comentario

BASH – Validar ingreso de un número (positivo, negativo o decimal).-

El siguiente código sirve para validar que el ingreso solicitado, corresponda a un número. Este puede ser positivo, negativo o decimal. Ejemplos de ingreso : +24 +24.324 12 12.22 -23 -23.45 etc….

#!/bin/bash
variable=$1
re='^[+-]?[0-9]+([.][0-9]+)?$'
if ! [[ $variable =~ $re ]] ; then
   echo "error: No es un numero"
else
   echo " Numero OK  :  $variable"
fi
Publicado en Unix - Linux | Deja un comentario

SCRIPTS – Variables especiales de BASH.-

$1, $2, $3, ... parámetros de posición que hacen referencia al primer, segundo, tercer, etc. parámetro pasado al script.
$_, el último argumento pasado al último comando ejecutado (justo después de arrancar la shell, este valor guarda la ruta absoluta del comando que inicio la shell).
$#, número total de argumentos pasados al script actual.
$*, la lista completa de argumentos pasados al script. Esta valor es una cadena de texto.
$@, la lista completa de argumentos pasados al script. Esta valor es una lista.
$-, la lista de opciones de la shell actual.
$$, el PID de la shell actual.
$IFS, el separador utilizado para delimitar los campos.
$?, el código de salida del pipe más reciente (es decir, de la última vez que se encadenaron varios comandos mediante el carácter pipe que se escribe como |).
$!, el PID del último comando ejecutado en segundo plano.
$0, el nombre de la shell o del script de shell.
Publicado en Unix - Linux | Deja un comentario

LINUX – Copia de directorios.

La copia recursiva incluye a una carpeta y todas sus subcarpetas. Por lo tanto, la estructura del directorio se copia entera. Esto no funciona con la copia sencilla del comando CP: si intentas copiar una carpeta sin el parámetro correspondiente, te saldrá un mensaje de error. El parámetro que debes usar es el ‘-r’, también conocido como ‘–recursivo’ o ‘-R’.

En nuestro ejemplo, queremos crear regularmente una copia de seguridad de una carpeta, incluyendo su contenido y subcarpetas. Para que no haya que copiar siempre todo el contenido del directorio, puedes utilizar el parámetro “update”.

cp -r -u /home/usuario/original/ /home/usuario/backups/

Cuando ejecutes el comando por primera vez, se te creará el directorio “original” dentro de la carpeta de backups. Todos los archivos y subdirectorios se te copiarán dentro de él. Si se trata de grandes cantidades de datos, esto puede llevar algún tiempo. Si utilizas el parámetro ‘-u’, solo copiarás los elementos modificados posteriormente.

Publicado en Unix - Linux | Deja un comentario

LINUX – Funciones especiales del comando CP.-

El comando CP de Linux también puede realizar otras tareas. Para ello, al comando se le puede añadir un término que contenga un parámetro:

cp [Parámetro(s)] [Origen(es)] [Destino]

Puedes introducir los siguientes parámetros (flags) en el campo para que el trabajo de copia sea más complejo o más fácil.

ParámetrosDescripciónEjemplo
-aCopia el archivo con la misma configuración de permisos y metadatos que el original.cp -a texto.txt /home/usuario/carpeta_de_destino/
–archiveCopia el archivo con la misma configuración de permisos y metadatos que el original.cp –archive texto.txt /home/usuario/carpeta_de_destino/
-bCrea una copia en la memoria intermedia (también llamada buffer) si el archivo original y el destino tienen el mismo nombre, pero diferente contenido.cp -b texto.txt /home/usuario/carpeta_de_destino/
–backupCrea una copia en la memoria intermedia (también llamada buffer) si el archivo original y el destino tienen el mismo nombre, pero diferente contenido.cp –backup texto.txt /home/usuario/carpeta_de_destino/
–backup=numberedCrea un nuevo archivo numerado si el archivo original y el de destino tienen el mismo nombre de archivo, pero diferente contenido.cp –backup==numbered texto.txt /home/usuario/carpeta_de_destino/
–backup=existingCrea un nuevo archivo numerado si el archivo original y el de destino tienen el mismo nombre de archivo, pero diferente contenido – y ya existen copias de seguridad numeradas.cp –backup==existing texto.txt /home/usuario/carpeta_de_destino/
-dCopia los enlaces simbólicos.cp -d texto.txt /home/usuario/carpeta_de_destino/
-fObliga a sobrescribir al copiar.cp -f texto.txt /home/usuario/carpeta_de_destino/texto.txt
–forceObliga a sobrescribir al copiar.cp –force texto.txt /home/usuario/carpeta_de_destino/texto.txt
-iPide permiso antes de sobrescribir archivos con el mismo nombre.cp -i texto.txt /home/usuario/carpeta_de_destino/
–interactivePide permiso antes de sobrescribir archivos con el mismo nombre.cp –interactive texto.txt /home/usuario/carpeta_de_destino/
-lCrea un enlace duro en lugar de una copia.cp -l texto.txt /home/usuario/carpeta_de_destino/
–linkCrea un enlace duro en lugar de una copia.cp –link texto.txt /home/usuario/carpeta_de_destino/
-nLos archivos existentes nunca se sobrescribirán.cp -n texto.txt /home/usuario/carpeta_de_destino/
–no-cobblerLos archivos existentes nunca se sobrescribirán.cp –no-cobbler texto.txt /home/usuario/carpeta_de_destino/
-pLos atributos del archivo original se heredan al copiar.cp -p texto.txt texto1.txt
–preserveLos atributos del archivo original se heredan al copiar.cp –preserve texto.txt texto1.txt
–preserve=modeEl modo del archivo original se hereda al copiar.cp –preserve==mode texto.txt texto1.txt
–preserve=ownershipLas propiedades del archivo original se heredan al copiar.cp –preserve==ownership texto.txt texto1.txt
–preserve=timestampLa marca de tiempo del archivo original se hereda al copiar.cp –preserve==timestamp texto.txt texto1.txt
–preserve=linksLos enlaces del archivo original se heredan al copiar.cp –preserve==links texto.txt texto1.txt
–preserve=contextEl contexto de seguridad del archivo original se hereda al copiar.cp –preserve==context texto.txt texto1.txt
–preserve=xattrLos atributos extendidos del archivo original se heredan al copiar.cp –preserve==xattr texto.txt texto1.txt
–preserve=allTodos los atributos del archivo original se heredan al copiar.cp –preserve==all texto.txt texto1.txt
-PLos enlaces simbólicos se guardan como tales al copiar.cp -P texto.txt /home/usuario/carpeta_de_destino/
–no-dereferenceLos enlaces simbólicos se guardan como tales al copiar.cp –no-dereference texto.txt /home/usuario/capeta_de_destino/
-rLos directorios, incluidos los subdirectorios, se copian de forma recursiva.cp -r /home/usuario/carpeta_de_origen/ /home/usuario/carpeta_de_destino/
-RLos directorios, incluidos los subdirectorios, se copian de forma recursiva.cp -R /home/usuario/carpeta_de_origen/ /home/usuario/carpeta_de_destino/
–recursiveLos directorios, incluidos los subdirectorios, se copian de forma recursiva.cp –recursive /home/usuario/carpeta_de_origen/ /home/usuario/carpeta_de_destino/
-sCrea un enlace simbólico para el archivo original.cp -s texto.txt /home/usuario/carpeta_de_destino/
–symbolic-linkCrea un enlace simbólico para el archivo original.cp –symbolic-link texto.txt /home/usuario/carpeta_de_destino/
-SSobrescribe un sufijo de backup al copiar con –backup.cp –backup=simple -S texto.txt /home/usuario/carpeta_de_destino/
–suffix=own_suffixSobrescribe con su propio sufijo el sufijo de backup al copiar con –backup.cp –backup=simple –suffix=own_suffix texto.txt /home/usuario/carpeta_de_destino/
-uCopia el archivo solamente si el archivo de destino es más antiguo que el original.cp -u texto.txt /home/usuario/carpeta_de_destino/texto.txt
–updateCopia el archivo solamente si el archivo de destino es más antiguo que el original.cp –update texto.txt /home/usuario/carpeta_de_destino/texto.txt
-vEmite un mensaje al terminar la copia.cp -v texto.txt texto1.txt
–verboseEmite un mensaje al terminar la copia.cp –verbose texto.txt texto1.txt
Publicado en Unix - Linux | Deja un comentario

BASH – Script para listar Directorios y Subdirectorios.

Script que lista todos los directorios y subdirectorios recursivamente de uno dado. El
directorio será introducido como argumento y el guion lo primero que hará será verificar si es
precisamente un directorio.

#!/bin/bash
if [ ! $# -eq 1 ] # Comprobar número de parámetros introducidos
then
 echo “¡¡ Error !! Uso: “$0” nom_dir”
 break
fi
 if [ -d “$1” ]
 then
 ls –lR “$1” | grep ’^d’
 else
 echo “No existe el directorio $1”
 fi 

Publicado en Unix - Linux | Deja un comentario

BASH – Script de automatización respuestas con EXPECT.

#!/bin/bash
#preguntas.sh
read -p "Cual es tu nombre: " nombre
read -p "Dime tu edad : " edad
read -p "Tu direccion actual : " direccion
read -p "Tu pais de residencia : " pais
echo ""
echo "$nombre tiene $edad y vive en $direccion de $pais"
echo ""
#!/bin/bash
#respuestas.sh
/usr/local/bin/expect <<EOF
spawn /usr01/home/monsyg/preguntas.sh
expect {
        "nombre" { send "Gonzalo\r" ; exp_continue }
        "edad" { send "57\r" ; exp_continue }
        "direccion" { send "Hernan Mery 1200\r" ; exp_continue }
        "pais" { send "chile\r" }
}
expect eof
EOF

El primer SCRIPT (preguntas.sh), al ejecutarlo solicita se ingresen lo datos por teclado. El segundo SCRIPT (respuestas.sh). Al ejecutarlo, lanza el SCRIPT preguntas.sh y ingresa las respuesta en forma automática. Esto mediante EXPECT. Pude obtener más información en esta misma WEB. A continuación se muestran los resultados obtenidos al ejecutar cada uno de los SCRIPTS :

moon@operadores $ ./preguntas.sh
Cual es tu nombre: Gonzalo Reiser
Dime tu edad : 57
Tu direccion actual : Hernan Mery 1200
Tu pais de residencia : Chile

Gonzalo Reiser tiene 57 y vive en Hernan Mery 1200 de Chile

moon@operadores $ ./respuestas.sh
spawn /usr01/home/monsyg/preguntas.sh
Cual es tu nombre: Gonzalo Reiser
Dime tu edad : 57
Tu direccion actual : Hernan Mery 1200
Tu pais de residencia : chile

Gonzalo Reiser tiene 58 y vive en Hernan Mery 1200 de chile

Publicado en Unix - Linux | Deja un comentario

BASH – Script para controlar espacio en disco.

           Script bash para vigilar en nuestros servidores linux el tamaño de disco de los sistemas operativos, para que nos advierta antes de que se llene.
#!/bin/bash
used=`df -h | grep usr02 | awk {'print $5'}`
USADO=${used/\%/}
if [ $USADO -gt 75 ];
then
echo "WARNING! El disco se est\341 llenando. El espacio utilizado = $USADO %" | mail -s "DISK" direccioemal@dominio.email
fi

Publicado en Unix - Linux | Deja un comentario

BASH – Creación de un bucle infinito.

#!/bin/bash
n=1
while :
do
         printf "The current value of n=$nn"
         if [ $n == 3 ]
         then
                   echo "good"
         elif [ $n == 5 ]
         then
                  echo "bad"
         elif [ $n == 7 ]
         then
                  echo "ugly"
         elif [ $n == 10 ]
         then
                   exit 0
         fi
         ((n++))
done
Publicado en Unix - Linux | Deja un comentario

BASH – Manipulación de cadenas de texto.-

Extraer subcadena

            Mediante ${cadena:posicion:longitud} podemos extraer una subcadena de otra cadena. Si omitimos :longitud, entonces extraerá todos los caracteres hasta el final de cadena.

            Por ejemplo en la cadena string=abcABC123ABCabc:

•	echo ${string:0} : abcABC123ABCabc
•	echo ${string:0:1} : a (primer caracter)
•	echo ${string:7} : 23ABCabc
•	echo ${string:7:3} : 23A (3 caracteres desde posición 7)
•	echo ${string:7:-3} : 23ABCabc (desde posición 7 hasta el final)
•	echo ${string: -4} : Cabc (atención al espacio antes del menos)
•	echo ${string: -4:2} : Ca (atención al espacio antes del menos)

             Borrar subcadena

             Hay diferentes formas de borrar subcadenas de una cadena:

•	${cadena#subcadena} : borra la coincidencia más corta de subcadena desde el principio de cadena
•	${cadena##subcadena} : borra la coincidencia más larga de subcadena desde el principio de cadena
Por ejemplo, en la cadena string=abcABC123ABCabc:
•	echo ${string#a*C} : 123ABCabc
•	echo ${string##a*C} : abc

Reemplazar subcadena

                También existen diferentes formas de reemplazar subcadenas de una cadena:

•	${cadena/buscar/reemplazar} : Sustituye la primera coincidencia de buscar con reemplazar
•	${cadena//buscar/reemplazar} : Sustituye todas las coincidencias de buscar con reemplazar
Por ejemplo, en la cadena string=abcABC123ABCabc:
•	echo ${string/abc/xyz} : xyzABC123ABCabc.
•	echo ${string//abc/xyz} : xyzABC123ABCxyz.

Publicado en BATCH - DOS | Deja un comentario

BASH – Algunos códigos obtenidos desde la WEB.-

#!/bin/bash
read -p "Please input the operation (create or delete ): " OPERATION   
// Ingrese la acción que desea realizar
case $OPERATION in
    create)              // El primer caso: crear
    read -p "Please input the userfile : "   USERFILE     // Solicitar archivo de entrada
    [ -e $USERFILE ] || {                                  // Determinar si existe
        echo "$USERFILE is not exist "
        exit 1
        }
    read -p "Please input the passwdfile :  " PASSFILE
    [ -e $PASSFILE ] || {
        echo "$PASSFILE is not exist "
        exit 1
        }
    USERLINE=`awk 'BEGIN{N=0}{N++}END{print N}' $USERFILE`  // Calcular el número de líneas de archivo de archivo de usuario
    for LINE_NUM in `seq 1 $USERLINE`  // usa loop para construir
    do
        USERNAME=`sed -n "${LINE_NUM}p" $USERFILE` // Intercepta la primera línea del archivo de archivo de usuario
        PASSWORD=`sed -n "${LINE_NUM}p" $PASSFILE` // Intercepta la primera línea del archivo de passfile
        useradd $USERNAME                                // Crear usuario
        echo $PASSWORD | passwd --stdin $USERNAME
    done
    ;;
    delete)      // La segunda situación: eliminar
    read -p "Please input the userfile : "   USERFILE
    [ -e $USERFILE ] || {
        echo "$USERFILE is not exist "
        exit 1
        }
    USERLINE=`awk 'BEGIN{N=0}{N++}END{print N}' $USERFILE`
    for LINE_NUM in `seq 1 $USERLINE`
    do
                USERNAME=`sed -n "${LINE_NUM}p" $USERFILE`
                userdel -r $USERNAME
    done
    ;;
    *)                       // La tercera situación: las diversas situaciones restantes
    echo Eorror!
    ;;
Esac
#!/bin/bash
/usr/bin/expect << EOF     // Cambiar al entorno esperado
spawn ssh root@$1        // IP de conexión ssh
expect {
    "yes/no" { send "yes\r";exp_continue }   // Confirma la conexión
    "password" { send "$2\r" }              // Ingrese la contraseña
}
Interact               // reservado
EOF                   // salir

#!/bin/bash
Auto_Connect()
{
/usr/bin/expect << EOF
set timeout 5
spawn ssh root@172.25.254.$IP_NUM hostname
expect {
    "yes/no" { send "yes\r";exp_continue }
    "password:" { send "westos\r" }
}
expect eof
EOF
}
for IP_NUM in {71..72}
do
    ping -c1 -w1 172.25.254.$IP_NUM &> /dev/null && {
    Host_Name=`Auto_Connect | grep -E "authenticity|fingerprint|connecting|password|spawn|Warning" -v`   // Filtrar advertencias y otras declaraciones
    }
    echo "      $Host_Name 172.25.254.$IP_NUM"
done

#!/bin/bash
Auto_Connect()
{
/usr/bin/expect << EOF
set timeout 5
spawn ssh root@172.25.254.$IP_NUM hostname
expect {
    yes/no { send "yes\r";exp_continue }
    password { send "redhat\r" }
}
expect eof
EOF
}
for IP_NUM in {226..227}
do
    ping -c1 -w1 172.25.254.$IP_NUM &> /dev/null && {
        Host_Name=`Auto_Connect | grep -E "authenticity|fingerprint|connecting|password|spawn|Warning" -v`
    }
    echo  "$Host_Name 172.25.254.$IP_NUM " | sed 's/\r//g'     // Reemplazar / r del texto completo con vacío.
Done

#!/bin/bash
Auto_Discuz()
{
/usr/bin/expect << EOF
set timeout 30
spawn ssh root@$1
expect {
    "yes/no" { send "yes\r";exp_continue }
    "password:" { send "westos\r" }
}
expect "]#" { send "yum install httpd -y\r" }
expect "]#" { send "yum install mariadb-server -y\r"}
expect "]#" { send "yum install php-mysql.x86_64 -y\r"}
expect "]#" { send "systemctl start httpd\r" }
expect "]#" { send "systemctl start mariadb\r" }
expect eof
EOF
}
Auto_Connect()
{
/usr/bin/expect  << EOF
set timeout 30
spawn ssh root@$1
expect {
    "yes/no" { send "yes\r";exp_continue }
    "password:" { send "westos\r" }
}
expect "]#" { send "cd /var/www/html/\r" }
expect "]#" { send "unzip /var/www/html/Discuz_X3.2_SC_UTF8.zip >> /dev/null \r" }
expect "]#" { send "chmod 777 /var/www/html/upload/ -R\r" }
expect "]#" { send "systemctl restart httpd\r" }
expect eof
EOF
}
Auto_Httpd()
{
/usr/bin/expect << EOF
set timeout 30
spawn ssh root@$1
expect {
    "yes/no" { send "yes\r";exp_continue }
    "password:" { send "westos\r" }
}
expect "]#" { send "sed "/^Listen/cListen 8080" -i /etc/httpd/conf/httpd.conf\r" }
expect "]#" { send "yum restart httpd -y\r" }
expect eof
EOF
}
yum install expect -y
Auto_Discuz $1
scp /home/kiosk/Downloads/Discuz_X3.2_SC_UTF8.zip root@$1:/var/www/html
Auto_Connect $1
firefox -new-tab $1/upload/install
Auto_Httpd $1

Publicado en Unix - Linux | Deja un comentario

LINUX – BASH script comando UNTIL.-

#!/bin/sh

CONTADOR=0
until [ $CONTADOR – ge 3]; do
    echo El contador es $CONTADOR
    CONTADOR=$(($CONTADOR+1))
done

Publicado en Unix - Linux | 2 comentarios