Por tal motivo, y ante un requerimiento del primer tipo (como “ayuda memoria”) quiero publicar algo que frecuentemente utilizo (o que cuando no es tan frecuente mi fragil memoria olvida):

¿Cómo hacer un loop infinito en un intérprete de comandos (sh, ksh o similar)?

Pongamos unas comillas al “infinito”, todo concluye al fin, nada puede escapar a un Ctrl+C o a un break (produce un abandono inmediato) dentro del bucle.

while :; do
  # Todo lo que quieras repetir infinitas veces
  echo "Hola Mundo"
  sleep 2
done

No olvides el sleep, sino pasarán cosas muy rápido

Otras opciones son utilizar las palabras especiales true (indica que una condición en verdadera) y false (indica que una condición es falsa) de bash:

while true; do
  ...
  ...
done

O:

until false; do
  ...
  ...

done

Como lo más destacado de este post, les dejo una cheatsheet de comandos de UNIX.

Y como plus, algunas cheatsheet varias, de esas que encontrarás miles en Internet. Son una hoja de referencia de vi/vim (a menos que trabajes hace tiempo con vi o vim, esta hoja te será muy útil inclusive para saber como salir del editor ).

Y además, otras dos hojas acerca de las equivalencias en colores RGB/Hexadecimal (para imprimir a colores) y otra de JQuery, estas últimas dos para webmasters por sobre todas las cosas.

Vía: PixelBeat

Vamos a ver un pequeño script para lograr este propósito utilizando algunos comandos ya vistos y utilizados en la historia de este blog con varios distintos propósitos (ifconfig, grep, cut, awk, wget, sed)

Primero, para obtener mi IP local (privada) puedo hacerlo mediante ifconfig, ahora, con la ayuda de grep, awk y cut quitaré todo lo que sobra para obtener solo la IP.

Segundo, con la ayuda de un sitio web  y wget obtendré mi IP pública, IP otorgada por el servidor de Internet al conectarme, por lo general es dinámica (a menos que paguemos a nuestro ISP por una IP fija). Al resultado obtenido con la ayuda de sed le dejaré tan solo la IP.

Finalmente, el script:

Vía: Be Linux my Friend

A las publicaciones de tiempo atrás de Center IM, mp3blaster y Lynx hoy aprenderemos a enviar tweets desde la terminal utilizando cURL-

cURL es una herramienta, que muy probablemente tengas instalado en tu GNU/Linux o BSD, que nos permite enviar a una datos a una URL utilizando los protocolos HTTP, HTTPS, FTP, FTPS, etc.

Bien, enviar un tweet desde la terminal es realmente muy sencillo, basta copiar la siguiente línea:

curl -u usuario:password -d status="Mi primer tweet desde la terminal" http://twitter.com/statuses/update.xml

Donde:

• Usuario: es tu nombre de usuario
• Contraseña: es tu clave de acceso
• status: es el texto del tweet
• http://twitter.com/statuses/update.xml: es la URL de la API que ofrece Twitter para el envio y recepción de datos. Verás que los tweets escritos de esta forma dirán debajo "hace 'tanto tiempo' via API"

Algo que obviamente puede no gustarnos de esto es escribir, a la vista de todos, la contraseña por terminal y lo que puede ser peor, que quede en el histórico. Para lo segundo, podemos borrar el history (history -c)

That's all folks.

Vía: 120% Linux

Veamos un ejemplo muy sencillito:

No hace mucha explicación ¿no?, el comando d recibe el número de línea a eliminar. Esto es muy sencillo y es el ejemplo más básico del uso de sed; simplemente para que te vayas amigando.

Ahora veamos un ejemplo similar, pero reemplazando palabras:

Ahora usamos el comando s, éste recibe una cadena a buscar y una cadena por la que se reemplazarán las coincidencias en todos sus archivos.

Finalmente, para cerrar esta breve introducción a sed veamos un ejemplito propuesto en Feelinfo ¿Cómo reemplazar textos en varios archivos en Linux?:

Sabiendo que "sed -i '/s/palabra-vieja/palabra-nueva/g' *.txt" reemplaza todas las ocurrencias de la palabra vieja por palabra nueva en todos los archivos:

Bien, esto es todo por ahora. Una observación para mi como para ustedes, no nos creamos que sed se limita a solo esto... manipulando flujos podemos dominar el mundo (¿no me crees? mira este rudimentario tetris escrito con sed, sedtris.sed)

Como debería ser sabido, todo en Unix se trata como archivo (archivos propiamente dichos, directorios, dispositivos, etc). El comando stat nos muestra el estado de archivos y del sistema de archivos tal como se podrá ver en este artículo.

Estadísticas de un archivo:

stat passwd

Donde entre otros datos se puede reconocer el tipo de archivo, la cantidad de links al mismo, los permisos de acceso en octal y con los caracteres rwx, el usuario y el grupo (id / nombre). Además de las fechas de acceso, modificación y cambio.

Estadísticas de un directorio:

stat /etc

Estadísticas del sistema de archivos:

stat -f /

Vía: The Geek Stuff

La historia cuenta que allá por 1969, días después de la llegada del hombre a la luna (si es alguien cree en ese discutible suceso) un programador llamdo Ken Thomson de Bell Laboratories (subsidiaria de AT&T) aprovechando la susencia de su mujer e hijo por vacaciones (que casualidad ¿no?) escribió la primera versión de Unix en un lenguaje ensamblador.

En marzo del mismo año, los mismos laboratorios habían renunciado a seguir con un ambicioso proyecto de sistema de tiempo compartido llamado Multics (Multiplexed Information and Computer Service), del que Thomson aplicó algunos principios y como broma al proyecto anterior denominó Unics (reemplazando la primer paralabra por Thomson Uniplexed) a su proyecto.

Como AT&T Bell vió que el proyecto tenía futuro decidió apostar al proyecto e incorporar a varios programadores de los cuales se destaca Brian Kernighan. Por motivos desconocidos UNICS pasa llamarse UNIX y va tomando forma adquiriendo nuvas funcionalidades y aplicaciones como cat, chmod, chown, cp, ls, mv, who, wc, etc. Si bien el desarrollo era rápido, el principal cuello de botella estaba en Ensamblador, es así que aparece Dennis Ritchie quien con colaboración de Kernighan escribe un lenguaje de más alto nivel, añadiendo nuevas funcionalidades y más abstracción que lo que ofrecía el lenguaje B. El éxito fue rotundo y para 1973 todo UNIX ya estaba re-escrito en C.

A todo esto, el departamento de defensa estadounidense empezó a financiar su red ARPANET y con ella la pila de protocolos TCP/IP. En 1974 la Universidad de California en Berkeley recibió una copia de los fuentes de UNIX y allí el desarrolló comenzó a dispararse pues se encargaron de implementar el protocolo TCP/IP.  Con esto, la conectividad en red (gran problema hasta el momento para Unix) quedó totalmente resuelto gracias a uso de sockets para las comunicaciones. Este punto fue el boom definitivo de Unix que se empieza a hacer presente en todos los servidores de red o computadoras del mundo.

Bill Joy, un recién graduado en Berkeley creó la primer versión de BSD (Berkeley Software Distribution) basada en Unix V6 de Bell Labs. Es aquí donde empieza una gran disputa legal entre Berkeley y AT&T, pues para distribuir el software (BSD) había que contar con licencias de AT&T. Pero llegó a un punto que la universisas había cambiado tantos aspectos internos del SO que la diferencia entre ambos Unix era enorme. Este conflicto duró  hasta 1994, cuando Novell compró en 1992 los derechos del Unix AT&T y acordó con la universidad que consistía en eliminar de BSD todo el código residual del Unix de AT&T.

En 1982 Bill Joy fue cofundador de Sun Microsystems, empresa que se basó en Sun OS para la venta de estaciones de trabajo y servidores. En 1983 aparece la primera versión de Unix System V, el cual sería base para los sistemas AIX de IBM y HP-UX de Heweltt Packard.

En medio de la batalla legal (década del 80), Bill Gates empieza a comercializar MS-DOS, un sistema mucho más pobre que Unix, pero con la particularidad en que podía correr en cualquier computadora personal (PC), de ahí nace la historia del imperio de Microsoft, del cual no hablaremos en esta publicación.

También, a finales de esa década un estudiante finlandés llamado Linus Torvalds decide crear su propio SO basado en Minix (SO creado como recurso pedagógico por el profesor Andrew Tanenbamum). Apenas Linus tiene un prototipo funcional escribe un mensaje en Usenet y así empezaba la histora de Linux)

Volviendo el tiempo atrás, en 1983 Richard Stallman se desvincula del MIT y comienza un movimiento que se transformó en marco de referencia moral, político y legal, el proyecto GNU. No solo a filosofar se dedicaba la comunidad GNU, al contrario, escribía cientos y cientos de aplicaciones (todas de ellas libres). GNU se tardó en escribir su SO (GNU Hurd), más que nada porque fue dejado para lo último dadas las ambiciones del proyecto que proponía una arquitectura microkernel por sobre las clásicas monolíticas.

El retraso de Hurd, la llegada de Linux y el montón de aplicaciones escritas por GNU llevó a una aparición casi anárquica GNU/Linux, que no era otra cosa que el kernel escrito por Linux Torvalds acompañado por un sin-numero de aplicaciones GNU. La popularidad de GNU desde entonces provocó en cierta medida el decrecimiento de la cuota de mercado de Unix, y a la vez llevó un "Clon de Unix" a los escritorios de las computadoras personales, hasta entonces monopolizado por empresas de software propietario.

Como bonus a la impresionante historia que acabamos de leer, le agregamos a los timelines publicados hace bastante (propiamente al timeline de UNIX) el siguiente diagrama (algo más simplificado) pero con el interesante agregado del tipo de distribución de su código fuente:

• Open Source
• Mixed/Shared Source
• Closed Source

Finalmente, una versión muy simplificada del mismo arbol de genealógico:

Vía: MuyLinux

Debido al gran volumen de datos, como estrategia de backups se decidió realizar un backup full  mensualmente y un backup incremental diario.

A tal fin, se escribieron dos scripts, el primero de ellos, que dado un directorio crea un tar comprimido del mismo. Y el segundo, el que se ejecuta diariamente, que se encarga de verificar la fecha de modificación del último backup full del directorio y a partir de la misma crea un tar comprimido con los cambios desde entonces.

Nada de otro mundo, dos scripts sencillos, pero que se dejan a vuestra disposición por si las moscas.

Backup Full:

Backup Incremental:

Usamos grep para buscar una palabra dentro de un archivo en Linux, pero... ¿hasta donde podemos llegar con su uso?

A continuación, en cada ejemplo, intentaremos trabajar con dos archivos de demostración iguales a los siguientes:

• Uso básico, buscar una cadena en un archivo

• Buscar una cadena en varios archivos

• Buscar sin coincidencia entre mayúsculas y minúsculas (uso del argumento -i)

• Buscar expresiones regulares

En este ejemplo buscamos aquellas líneas que contienen la palabra "esta" y luego de cualquier texto (*) continúan con "linea". Para más operadores de expresiones regulares se recomienda leer la documentación del grep.

• Buscar palabras completas (excluir subcadenas) (uso del argumento -w)

• Buscar N líneas luego de la coincidencia

• Buscar N líneas antes de la coincidencia

• Buscar N líneas alrededor de la coincidencia

• Resaltar los resultados

Es necesario setear las variables de entorno GREP_OPTIONS y GREP_COLOR

• Buscar en archivos recursivamente (uso del argumento -r)

Cuando necesitas buscar una cadena en los archivos del directorio actual y sus subdirectorios. El siguiente ejemplo buscaría la palabra "auto" en todos los archivos del directorio actual y sus subdirectorios.

• Buscar no coincidencias (uso del argumento -v)
  

• Mostrar las lineas de varias no coincidencias (uso del argumento -v y los argumentos -e)

• Contar el número de ocurrencias (uso del argumento -c)
  

• Mostrar solo los nombres de los archivos los cuales contienen coincidencias (uso del argumento -l)

• Mostrar solo la cadena buscada (uso del argumento -o)

Por defecto el comando grep muesrta la línea completa de la cadena o patrón dado, pero si solo quieres mostrar dicha cadena o patrón puedes utilizar el argumento -o.

Nota la diferencia en el ejemplo:

• Mostrar la posición en el archivo de la conicidencia (uso de argumento -b)

• Mostrar la fila en el archivo de la conicidencia (uso de argumento -n)

Vía: The Geek Stuff

Si bien existen otras alternativas más versátiles, como emacs, pico (nano), etc., vi está presente en todos los UNIX, requiere pocos recursos y se usa mucho en administración (para programar y en situaciones de emergencia)

Con las razones antes expuestas es prácticamente imprescindible que tengas y/o adquieras algún conocimiento de vi.

Para empezar, lo primero que debemos conocer de vi son sus "modos". Existen tres modos o estados en vi:

• Modo comando: permite desplazarse por el documento con las teclas de cursos, recorrer el archivo y ejecutar comandos de manejo de texto o salir del editor.
• Modo texto o insersión: permite el ingreso de caracteres en el documento
• Modo "ultima línea" o ex: permite escribir comandos (comandos que se ven en la última línea de la pantalla)

A continuación, lo básico que hay que saber para no pasar vergüenza o sentir impotencia es:

• vi mi_archivo: edita el archivo mi_archivo
• i: inserta texto a la izquierda del cursor
• a: agrega texto a la derecha del cursor
• ESC: vuelve a modo comando
• x: borra el caracter bajo el cursor
• dd: borra una línea
• dw: borra una palabra
• h o flecha izquierda: mueve el cursor un caracter a la izquierda
• j o flecha abajo: mueve el cursor una línea hacia abajo
• k o flecha arriba: mueve el cursor una línea hacia arriba
• l o flecha derecha: mueve el cursor un caracter a la derecha
• 0: mueve el cursor al principio de la línea
• $: mueve el cursor al final de la línea
• 1G: mueve el cursor al principio del archivo
• G: mueve el cursor al final del archivo
• u: deshace el último comando
• :w: guarda el archivo
• :w nombre_archivo: guardar como nombre_archivo
• :q: sale del editor (debe guardarse el archivo primero)
• :q!: sale del editor sin grabar
• ZZ: guarda el archivo y sale del editor
• /palabra: busca palabra

¿Como cambiar de modos?

• De comando a texto:
  • teclas de inserción i I a A o O
  • tecla de sobreescritura R
• De texto a comando:
  • tecla ESC
• DE comando a última línea:
  • teclas : / ?
• De última línea a comando:
  • tecla ENTER (al finalizar el comando)
  • tecla ESC (interrumpe el comando)

Uno de los problemas más frecuentes en el uso de vi es saber donde estamos (en que modo). Esto se facilita enormemente con un seteo a escribir en modo comando: :set showmode. De ahi en más veremos una leyenda que indica si estamos en modo comando o inserción.

La lista de comandos continua y es mucho más larga y prácticamente fin, pero como nuestro objetivo en esta publicación es simplemente "sobrevivir", vamos a plantear un último aspecto interesante y dar por finalizada esta guía:

¿Cómo copiar y pegar con vi?

• yy: copiar línea
• yw: copiar palabra
• y$: copiar desde el cursor hasta el fin de la línea
• p: pegar a la derecha de la posición cursor
• P: pegar a la izquierda de la posición cursor

Un detalle más, ausente en muchos editores más sofisticados, es el de copiar en buffers, los comandos son los mismos, pero son antecedidos por el nombre del buffer, por ejemplo:

• ayy: copia línea en buffer "a"
• ayw: copia palabra en buffer "a"
• ap: pegar a la derecha de la posición del cursor el buffer "a"
• aP: pegar a la izquierda de la posición del cursor el buffer "a"
• bdd: borra la línea y la guarda en e buffer "b" (equivalente a cortar)
• bdw: borra la palabra y la guarda en e buffer "b" (equivalente a cortar)

Y esto fue todo por hoy, no te habrás convertido en un experto, pero de seguro fue más que suficiente para dar los primeros pasos.

Vía: Instituto de Ingeniería Eléctrica