Manipulando I/O con pipelines.

Advertencia:

• Recomiendo leer las entradas de $man  $cat, $watch, $history y $less antes de seguir leyendo esto.

• He recomendado previamente wikear e investigar acerca del concepto I/O. Es importante que veamos todas las interacciones con nuestras PCs (y yo me atrevo a incluir, la vida en general) de esa forma: 

Input | Output

Entrada | Salida

O sea: 

Causa | Efecto

Instrucciones | Resultados.

Mientras entendamos esto, todo bien; caso contrario, te toca leer manuales externos porque a este punto, asumimos que estamos claros con este concepto y evitaremos elaborar.

Intro:

He instalado VirtualBox en un servidor. Me conecto al servidor desde mis otros equipos desde la CLI (eso es un cuento para luego... ahorita no joven). Hice una pausa en este proyecto por un par de semanas porque obtuve una netbook de segunda mano y he pasado jugando con Arch en ella. Para configurar una virtualbox en Terminal, hay que hacer varias cosas y apenas las recordaba hoy, enero/16; a grandes rasgos: crear una nueva virtual machine, asignarle x cores del cpu, x cantidad de RAM y VRAM, crear un HDD virtual, un ODD virtual, agregar controlador, etc.

Viendo a futuro, y contando con que planeo usar otra unidad de arranque para el servidor, o pueda cagarme en algo (cosa que hago a menudo :v ), probablemente necesite reinstalar virtualbox, o al menos borrar una VM, clonar, crear, restaurar otra. Por ello, quiero guardar un resumen de los comandos usados (como lo hice al aprender a instalar Arch recientemente); a modo de referencia.

**** Resumen ****

Necesito extraer los comandos que he usado para configurar la VM dentro del servidor. El comando (el principal) para gestionar Virtual Machines dentro de VirtualBox en la CLI es:

$vboxmanage
(o sea, "virtualbox manage": gestionar caja virtual). Recuerdo que lo he usado una, y otra, y otra**10 vez). Tuve una idea: buscar todas las instancias de ese comando, copiarlas y pegarlas en un documento de texto que luego puedo guardar en mi netbook u otro equipo. Para ello:

$ history | grep -i vboxmanage > vbox_resumen-de-comandos.txt

Y listo. Si has revisado las entradas antes mencionadas, sobran las explicaciones. Una vez creado el documento, lo abro:

$ less  vbox_resumen-de-comandos.txt

Y veo  todas las instancias que he usado del mismo comando (algunos de ellos, repetidos o con "typos"). Luego de eso, es posible editar  y depurar los errores (con gedit, leafpad, nano, etc.); incluso, puedo agregar notas aclaratorias. Creo tener una entrada antigua sobre editores de texto en este blog; te invito a buscarla. Eso es todo; gracias por leer :D

Comando watch: ejecución de programas periódicamente

NOTA: Como lo mencionaba antes, los artículos que compartiré de ahora en adelante pueden o no ser adecuados para novatos; porque requieren un poco más de esfuerzo y conocimiento para previo para entenderlos. Este artículo habla de  dos cosas: primero, el uso de un comando nuevo y muy útil, pero cuyo potencial no se aprovecha si no hablamos de lo segundo: las pipelines o tuberías. No vamos a profundizar en el segundo aspecto porque, aunque no es extenso, requiere especial atención y dedicación; le veremos de grosso modo para entender la flexibilidad de los sistemas operativos Unix. Si estás interesado en las pipelines, te sugerimos investigar en línea mientras publicamos algo dedicado a ellas. 

Según 

$ whatis watch

watch (1)            - execute a program periodically, showing output fullscreen

Traduciendo: 

watch (1: comando de usuario) - ejecutá un programa periódicamente, mostrando el resultado en pantalla completa (o sea, abarca toda la Terminal).

Watch es un programa que ejecuta programas. ¿Por qué "watch" ("observar", "mirar")? ni idea; no lo he buscado, pero sospecharía que tiene que ver con su propósito: mostrar el resultado (el output) en la Terminal. Esto nos puede ayudar cuando queremos observar cambios en un documento o un proceso.

Por ejemplo,

Me estoy descargando un archivo de internet. Digamos que cerré la interfaz de la aplicación pero ella sigue corriendo en el background y no quiero volver a abrirla ―por pereza o porque no quiero que su GUI me gaste RAM que puedo dedicar a otra cosa― pero quiero saber cómo va la descarga. Entonces, recuerdo que antes hablábamos del comando ls, útil para LISTAR directorios y archivos en el filesystem. 

ls -s muestra el tamaño de los archivos (en Bytes, pero esto puede ser modificado según se necesite: $ ls --block-size=1M)

Entonces, si watch me permite ejecutar un programa cada cierto tiempo, puedo hacer que watch monitoree el tamaño del archivo, reportado por ls -s, conforme crece):

$ watch -n4 ls -s downloads/archivo_siendo_descargado_por_otro_programa

Te recuerdo que podés hacer esto para un archivo localizado en cualquier directorio si sabés la ruta absoluta o relativa a usar. Y esto te reportará un output así:

Instalamos FreeBSD hace un par de años y pensamos hacerlo de nuevo; esta vez con un poquito más de conocimiento para apreciarle y usarle mejor :)

Otro ejemplo:

(un poco más complejo) El otro día quería ver -por curiosidad- los cambios en tiempo real de la velocidad de mi CPU (cuando digo CPU, me refiero al microchip, al procesador, no al cajón de desktop; este es un término mal usado y debemos de dejar de hacerlo). Un colega en un grupo de Linux en FB decía que Ubuntu mantenía a sus procesador al máximo y por eso calentaba su laptop... pero recuerdo que una vez ya había medido la velocidad de mi CPU en tiempo real con watch dentro de Freya cuando tenía mi Phenom 960T; revisé los documentos de nuevo y para salir de la duda, lo hice en mi laptop nueva. 

La info del procesador se puede obtener de muchas formas según encontré en sitios diversos; pero me voy a enfocar en una manera simple. Primero, te voy a recordar el uso del comando cat.

$ cat /proc/cpuinfo  

muestra información relacionada a tu procesador: 

Según el número de núcleos detectados por tu sistema, esta muestra aparecerá una o más veces con diferente # en el primer campo (processor); en el caso de un Intel móvil, aparece cuatro veces, enumerados del 0 al 3 (este i5 es dual core, pero Intel hace uso de su Hyper Threading, duplicando el número de hilos como si fueran el doble de núcleos).

Y esto es útil, pero hay dos cosas:

• Sólo me muestra la velocidad base (donde está el modelo del cpu) y la velocidad en MHz al momento de ejecutar este comando (2670.281 MHz, o sea, 2.67GHz)

• Me llena la Terminal de información totalmente inútil/que no me importa de momento. Sólo quiero saber los cambios de velocidad en tiempo real o intervalos, no todas las tech specs del cpu.

Aquí es donde watch es útil:

Aplicando Pipelines:

Para mostrarte lo que quiero decir, usaremos adicionalmente el comando (que no vamos a ver con detalle, porque su uso es extenso y flexible) grep, que sirve para buscar patrones específicos de texto en un documento/archivo. 

vamos primero a usar una pipeline para unir a ambos comandos: 

cat | grep 

Esto se leería algo así: 

mostrar info (para el caso, del procesador); y usar una tubería (el " | " es una "pipe" o tubería) para que el resultado de cat, sea procesado por grep, quien se encargará de filtrar la info innecesaria y sólo de mostrar la sección específica que queremos. Las pipelines toman el resultado (output) de un comando y lo usan como info de entrada (input) de otro comando para que este haga una tarea con ella y la procese de forma que dé, otro resultado (otro output).

Vamos entonces con cualquiera de estos: 

$ cat /proc/cpuinfo | grep MHz

$ cat /proc/cpuinfo | grep -i mhz

Ambos van a lo mismo,  la opción " -i " dice a grep que sea indiferente a la capitalzación (en buen salvadoreño: que le valga verga si  hay mayúsculas o no, que igual muestre resultados si los encuentra). Entonces esto nos arroja lo siguiente:

Hasta ahí todo bien. PEEEEEEROOOOOooooOOOOooo... muestrala velocidad grabada al momento de ejecución; no en tiempo real. Aquí hacemos uso de watch: 

$ watch -n2 " cat /proc/cpuinfo | grep -i mhz "

Y este es el resultado: 

"Every 2.0s:" ... con -n2 establecí que watch ejecute cat | grep cada dos segundos. Y los cambios son reportados puntuales: 

-

Y listo.

En resumen: 

• watch nos sirve para ejecutar otros comandos (o sea, otros programas) a intervalos definidos por el usuario/administrador. Así podemos monitorear en tiempo real, procesos y tareas que estamos ejecutando.

• las pipelines ( cuando veás este símbolo en un comando o combinación de ellos " | ", seguramente estás frente a una pipeline) nos sirven para ejecturar comandos consecutivamente, y que el resultado de uno, sea manipulado y procesado por otro.

Ambos ejemplos son relativamente rústicos para las herramientas con las que contamos actualmente; el propósito de estos artículos es 1) familiarizarte con tu Terminal y la CLI, 2) prescindir de bloatware (software innecesario) que desperdicie espacio en tu disco, y de GUIs que utilizan recursos extra para llegar a lo mismo, 3) mostrarte la flexibilidad y potencial de las herramientas de Terminal, valoradas especialmente por SysAdmins veteranos y expertos del FOSS. 

Espero que te haya gustado y sido útil esta nota. Compartila, comentá y avisanos si te gustaría que hablemos de otros temas en particular. Saludos :) 

Comando kill: asesiná procesos atacados.

Como n00b es difícil no meter la pata muy de vez en cuando. Justo hace unos momentos estaba reinstalando Noise (Music en Freya y Luna) para diagnosticar e intentar un problema que tuve con él y mi librería de música. Se instala con  

$ sudo apt-get noise 

cuando recordé que en algunos sitios he encontrado la siguiente variación:

$ sudo apt-get install -y nombre_del_programa_a_instalar_acá

y al hacer esto, el prompt que anuncia:

"After this operation, 4,829 kB of additional disk space will be used. Do you want to continue? [Y/n]" 

se salta, tal y cual lo describe $ apt-get --help, así que ya no es necesario estar presente durante la descarga para decir que "sí" a la instalación (vamos que podés ir al baño o por comida al refrigerador mientras la tarea corre por sí sola). La opción -y significa "Assume Yes to all queries and do not prompt": asumir que sí a las preguntas y no pedir respuesta. Como decía, recordé esa opción -y así que cancelé con Ctrl + z la operación. Cosa que fue tonta porque pude simplemente contestar "n" para abortar.  Así que cuando intenté 

$ sudo apt-get install -y noise

Recibí 

E: Could not get lock /var/lib/dpkg/lock - open (11: Resource temporarily unavailable)
E: Unable to lock the administration directory (/var/lib/dpkg/), is another process using it?

Intenté nuevamente, recibí el mismo error. Yo fui el responsable de este problema. Luego de una Googleadita rápida, descubrí que el /var/lib/dpkg es un directorio usado cuando APT está procesando una paquete/programa para su descarga e instalación. Al menos esa es la explicación más útil que encuentro para mi nivel de conocimiento. El punto es, no podía instalar porque el directorio usado para tal fin está "bloqueado y siendo usando por otro proceso". 

Busqué información para resolver esto. Hace tiempo conocí a kill y pkill pero esta vez no sabía cómo identificar el proceso. Entonces en un maravilloso thread del foro de Ubuntu, encontré las siguientes instrucciones: 

Primero: Identificar el ID del proceso que está atascando al apt-get:

$ ps aux | grep apt
este comando nos mostrará el número del proceso que está usando el apt del comando apt-get:

root      6020  0.2  0.0  72648  4020 pts/14   S+   22:07   0:00 sudo apt-get install noise
root      6021 11.0  0.7  90548 59296 pts/14   S+   22:07   0:00 apt-get install noise


El número del proceso se muestra en la segunda columna, justo después del nombre de usuario (para el caso, recordemos que sudo = SuperUserDO, lo que implica que es el root quien instala). 

Segundo: con esta información, podemos darle jaque mate al proceso:

$ kill -9 6020

El -9 es una opción dada por el comando kill e implica que el proceso será terminado forzosamente; o sea, que le damos jaque mate irremediable.  Ya con esto, pude continuar felizmente mi camino de destrucción accidental :v 

Espero que esto sirva. Recordá, si un día se atasca el apt-get, 

$ ps aux | grep apt

y 

$ kill -9 númerodeprocesoacá

son tus mejores amigos :)