LuAuF

Ayuda memoria: loops infinitos en el shell

Luciano — Fri, 27 Jan 2012 01:44:47 +0000

Este blog, me ha sido en más de una ocasión, mi ayuda memoria ideal. En otras tantas ocasiones, un link al mismo me permitió “ayudar al prójimo”, más bien, ahorrarme tiempo de utilización de cuerdas vocales y ahorrar al otro el fastidio de escucharme.

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

until false; do
  ...
  ...

done

Exportar una base de datos MDB a SQL (mysql, oracle, sybase, etc.)

Luciano — Tue, 13 Sep 2011 02:00:38 +0000

Recuerdo instantes de mi pasado donde he tenido la necesidad de llevar Bases de Datos MDB, Microsoft Access, a bases de datos MySQL.

Recuerdo por entonces MySQL Migration Toolkit, una herramienta para realizar esta carga requerida. No obstante no era de mi agrado, y lo que buscaba por entonces era simplemente obtener un script SQL con el código DDL y DML necesario para el CREATE de los objetos de la base de datos y los INSERTs de los datos. A esa utilidad, hoy Linuxeando, le encontré el nombre: mdbtools.

MDBtools es un suite de herramientas (mdb-array mdb-header mdb-parsecsv mdb-schema mdb-tables mdb-export mdb-hexdump mdb-prop mdb-sql mdb-ver) que permiten, entre sus funciones, obtener esquema de una base de datos y exportar en SQL los datos de la misma.

Veamos un ejemplo básico y sencillo que consiste en:

Exportar el diseño de la vieja y querida Neptuno.mdb (conocida base de datos distribuida como ejemplo con Microsoft Access) en formato de sentencias de definición de datos SQL.
Obtener el nombre de las tablas de la misma base de datos
Exportar los datos de cada tabla bajo la forma de INSERTs SQL.

$ sudo aptitude install mdbtools

$ mdb-schema Neptuno.mdb mysql> Neptuno_schema.sql #donde mysql se puede reemplazar por otro dialecto: oracle, sybase o postgres.

$ for tabla in `cat Neptuno_tables.txt`; do mdb-export -R \; -I Neptuno.mdb ${tabla}; done> Neptuno_data.sql

$ rm Neptuno_tables.txt

Fácil, sencillo y util... lástima que en mi caso llega tarde, no obstante en conocimiento perdura y nadie puede asegurarme que no me encuentre alguna vieja MDB en mi camino.

Vía: Wikipeando

¿Cómo conectarse a MySQL desde un programa en C?

Luciano — Sat, 09 Jul 2011 18:01:54 +0000

La respuesta al título de esta publicación es muy sencilla, conectarse a MySQL desde C se realiza mediante una API provista por el mismo proveedor de base de datos.

La API de C es ditribuida con MySQL, no es más que una librería (libmysqlclient) que interfacea entre el programa y la base de datos.

La documentación provista por MySQL es muy completa (MySQL C API), no obstante, fiel a nuestra costumbre iremos a un ejemplo sencillo y concreto.

¿Qué necesitamos?

Un servidor de base de datos MySQL, al cual conectarnos
Un programa cliente
La librería mysqlclient
mysql-devel, headers con la firma de la librería
gcc

Con cualquier variante de UNIX más la instalación manual de la distribución binaria (tar.gz) tendremos todo lo que necesitamos. Caso contrario habrá que instalar los paquetes necesarios que incluya los requisitos mencionados, por ejemplo mysql-devel.

Primero, sin ir al detalle en concreto de cada línea (no cuesta nada interpretar el código, pues está bien comentado) veamos el siguiente fuente:

/* mi_cliente */
#include
#include

main() {
MYSQL *conn;
MYSQL_RES *res;
MYSQL_ROW row;

char *server = "localhost";
char *user = "root";
char *password = "PASSWORD"; /* set me first */
char *database = "mysql";

conn = mysql_init(NULL);

/* Connect to database */
if (!mysql_real_connect(conn, server,
user, password, database, 0, NULL, 0)) {
fprintf(stderr, "%s\n", mysql_error(conn));
exit(1);
}

/* send SQL query */
if (mysql_query(conn, "show tables")) {
fprintf(stderr, "%s\n", mysql_error(conn));
exit(1);
}

res = mysql_use_result(conn);

/* output table name */
printf("MySQL Tables in mysql database:\n");
while ((row = mysql_fetch_row(res)) != NULL)
printf("%s \n", row[0]);

/* close connection */
mysql_free_result(res);
mysql_close(conn);
}

Ahora si veamos la parte más interesa saber ¿cómo compilar?

Entre los argumentos a pasarle al gcc tenemos los directorios con las librerías, las librerías propiamente dichas, los directorios de encabezados (.h), y otras opciones más del compilador. Esto no representa ningún problema, menos aún con mysql_config es un pequeño utilitario de MySQL que provee información para el compilador.

De esta forma:

mysql_config --libs: devuelve los path de las librerías y las librerías propiamente dichas a linkear.
mysql_config --cflags: devuelve, entre otros argumentos, los path de los headers.

Finalmente, podemos compilar de esta manera tan sencilla:

$ gcc -o mi_cliente $(mysql_config --cflags) mi_cliente.c $(mysql_config --libs)

Y luego ejecutar:

$ ./mi_cliente

Realmente, muy sencillo ¿no?

Vía: nixCraft

Ya falta menos para Gnome 3

Luciano — Thu, 27 Jan 2011 00:54:37 +0000

En medio de las vacaciones de verano del hemisferio sur, y entre tantas pobres noticias del mercado futbolero y automotriz; aparece en mis feeds GNOME 3 - Made of Easy. Fue esa lectura la que me hizo recordar de Gnome 3, la esperada novedad que debería salir a la luz no antes de Abril del presente año... aunque de ahí a que llegue a las principales distros de Linux habrá que esperar algo más.

"El nuevo escritorio de GNOME eleva la elegancia a un nuevo nivel. Simple, bello, GNOME3 ha el desorden existente para llegar a un escritorio sencillo, simple, facil de usar y más hermoso que nunca; con nuevo tema, nueva fuente y animaciones cuidadas."

No obstante, ansioso, sin poder esperar su lanzamiento hice lo mismo que había echo tiempo atrás, Try it out!. El proceso es sencillo, bajar los fuentes y compilar... cosa que está bien aqui, que se resume en pocos pasos y que de no mediar problemas, apt-get install's de por medio se resume en:

curl -O http://git.gnome.org/browse/gnome-shell/plain/tools/build/gnome-shell-build-setup.sh
/bin/bash gnome-shell-build-setup.sh
sudo rm -rf /usr/lib*/*.la
jhbuild build

Finalmente, para ejecutar el nuevo shell:

cd ~/gnome-shell/source/gnome-shell/src
sudo ./gnome-shell --replace

Luego de eso, deberiamos poder empezar a disfrutar de un entorno nuevo, sencillo, cuidado y que representa la principal innovación en GNOME en años.

Borrar los archivos de más de N días (en Windows)

Luciano — Sat, 04 Dec 2010 19:19:03 +0000

Las publicaciones al blog son cada vez más esporádicas, no por eso poco importantes. Es decir, aveces prefiero publicar poco y útil antes que periódico e inservible.

En este caso, quiero aportar a este blog (mi humilde base de conocimientos) una forma muy sencilla de eliminar archivos de más de N de días de antigüedad en forma automática (ideal para ejecutar por el programador de tareas), algo muy útil para purgar logs o borrar temporales inútiles. En mi caso, fue utilizado para eliminar imágenes periódicas de una cámara IP (JPEG posting) que al final del día unía en un video diario.

Luego de buscar y buscar y estando a punto de escribir un Windows shell script bastante artesanal me encontré con FORFILES, un comando de Windows, que permite de una forma sencilla de seleccionar uno o más archivos y ejecutar un comando sobre los mismos.

Está de más decir que lo primero que deberías hacer es ver como funciona FORFILES:

forfiles /?

De todas formas, si eres algo perezoso, aquí va la solución al problema que da título a esta presentación:

forfiles -p "C:\donde\esten\tus\archivos" -s -m *.* -d -c "cmd /c del @path"

Vía: stackoverflow

Hojas de referencia de comandos de UNIX, vi/vim, etc.

Luciano — Mon, 27 Sep 2010 11:00:14 +0000

Y un día volví... y como no podía ser de otra manera con las clásicas hojas de referencia, para imprimir y tener a nuestro lado en los escritorios.

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

Usar discos reales en Virtualbox

Luciano — Mon, 10 May 2010 11:00:50 +0000

Un tip para tener a mano que resuelve las siguientes dos cuestiones:

Virtualizar un Sistema Operativo ya instalado en una partición existente

Crear un nuevo disco virtual en Virtualbox que apunte a una partición, sobre la cual se instalará un Sistema Operativo (desde una máquina virtual) y que luego se utilizará sin virtualizar.

Bien, para uno u otro fin necesitamos crear un disco virtual (.vmdk) pero que "apunte" a una partición real. Para el primer objetivo la partición existe y ya tiene un Sistema Operativo instalado. Para el segundo objetivo debemos, al menos, crear la partición (sin necesidad de formatear ni nada, simplemente crear la partición, puedes valerte de Gparted para esta tarea).

Finalmente, creamos el "link":

$ VBoxManage internalcommands createrawvmdk -filename /path/to/file.vmdk -rawdisk /dev/sda -relative -register

Vía: CRySoL

¿Como conocer mi IP privada y mi IP pública?

Luciano — Sun, 25 Apr 2010 02:07:31 +0000

¿Como conocer mi IP privada y mi IP pública?, esa es la cuestión.

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.

ifconfig | grep 'inet:'| grep -v '127.0.0.1' | cut -d: -f2 | awk '{print $1}'

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.

wget -q -O - checkip.dyndns.org|sed -e 's/.*Current IP Address://' -e 's/<.*$//'

Finalmente, el script:

#!/bin/sh
echo "IP privada: "$(ifconfig | grep 'inet:'| grep -v '127.0.0.1' | cut -d: -f2 | awk '{print $1}')
echo "IP pública: "$(wget -q -O - checkip.dyndns.org|sed -e 's/.*Current IP Address://' -e 's/<.*$//')

Vía: Be Linux my Friend

Enviar tweets desde la terminal

Luciano — Mon, 19 Apr 2010 11:00:30 +0000

Casi dos meses después de la última publicación, es necesario dar "señales de vida" del blog, que nunca fue discontinuado... pero que se mantuvo en "pausa" por falta de "inspiración" Y para volver, que mejor que con un clásico: hacer "cosas" desde la terminal (hoy estoy muy "comillero")

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

Reemplazar cadenas en archivos con sed

Luciano — Mon, 01 Mar 2010 11:00:28 +0000

sed es un "editor de textos" para el filtrado y la transformación de textos. Escribo "editor de texto" entre comillas pues en realidad sed no trabaja con cadenas de caracteres sino con "flujos", la diferencia con los editores de textos clásicos (interactivos) es que sed acepta como entrada estándar un archivo o cualquier otro stream; resultado que es procesado y devuelto a la salida estándar (vea más acerca de stdin, stdout y stderr aquí)

Veamos un ejemplo muy sencillito:

$ cat saludo.txt
hola
maldito
mundo

$ sed '2d' saludo.txt
hola
mundo

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:

$ sed 's/maldito/bendito/' saludo.txt
hola
bendito
mundo

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:

sed -i 's/Pepe/Jose/g' *.txt
sed -i 's/Manolo/Manuel/g' *.txt
sed -i 's/Nacho/Ignacio/g' *.txt
sed -i 's/Inma/Inmaculada/g' *.txt

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)