luauf.com

Alinear a la derecha los botones minimizar, maximizar y cerrar de Chromium en Gnome

Luciano — Fri, 04 May 2012 06:00:09 +0000

Una nueva ayuda memoria, en este caso, como alinear a la derecha los botones Minimizar, Maximizar y Cerrar en Chromium.

Luego de instalar Ubuntu 12.04, gnome-shell y de personalizar todos los detalles de mi escritorio, me encontré con un detalle estético poco feliz, que no era de mi agrado (que conste que era simplemente una cuestión personal). El detalle: los botones Minimizar, Maximizar y Cerrar de Chromium alineados a la izquierda x-(

Como es la segunda vez que me encuentro con el mismo problema, y buscar la solución me demandó unos 10 minutos que no quiero perder la pròxima, dejo sentada aquí mi ayuda memoria:

Para cambiar la alineación de los botones minimizar, maximizar y cerrar a la derecha, simplemente ejecutar en una terminal:

gconftool-2 –type string –set /apps/metacity/general/button_layout “menu:minimize,maximize,close”

Si te gusta como quedaban a la izquierda (yo paso), puedes regresarlos de la siguiente forma:

gconftool-2 –type string –set /apps/metacity/general/button_layout “close,minimize,maximize:”

En uno u otro caso la actualización es inmediata, no se requiere reiniciar absolutamente nada.

Introducción a Control de Versiones con Git

Luciano — Sun, 26 Feb 2012 00:47:54 +0000

Git es un software de control de versiones, como lo son, por ejemplo: CVS, SVN o VSS.

Git fue diseñado por Torvalds con el objetivo de llevar el kernel de Linux en un repositorio confiable o como el propio Linus dijo “rápido, muy rápido, fácil, bonito y espectacular”.

Una de las referencias de Linus en el diseño de git fue CVS, pero como un ejemplo de lo que NO HAY QUE HACER, pues lo sufrió durante siete años en una compañía y allí aprendió a odiarlo con pasión. Linus tampoco quizo probar con SVN, pues el lema de SVN era “hacer CVS bien”, y eso ya lo condenaba, pues no había forma de hacer a CVS bien.

Dejando de lado las anécdotas anteriores, Git es utilizado por la mayoría de los desarrollos open source de la actualidad:

El propio Git
Linux Kernel
Perl
Eclipse
Gnome
KDE
Qt
Ruby on Rails
Android
PostgreSQL
Debian
X.org

Para quienes no saben lo que es un software control de versiones, básicamente, se puede resumir en un servidor donde se suben los archivos de un proyecto y a medida que se van modificando se van registrando y documentando estos cambios (versionando). En principio la idea es sencilla y más de un improvisado podría cuestionar el uso del mismo. No obstante, en la medida que un proyecto crece, la cantidad de archivos aumenta, los cambios y la cantidad de programadores también, resulta totalmente insostenible trabajar sin un control de versiones.

Trabajar sin control de versiones implica no saber donde está el último fuente, arrancar trabajando de una versión anterior y perderse los cambios de la que realmente era la última, no saber cuales son y quien realizó los cambios, no deshacer fácilmente los cambios realizados (downgrade), o no poder facilitar la transición a una versión totalmente nueva de un proyecto manteniendo el soporte a la anterior.

Una cosa más, la mayoría de los IDEs actuales tienen integración con Git, o si no la tienen, tienen algún plugin para hacerlo. Ahora, si no utilizas un IDE, tu caso es un poco más delicado

Sin más preámbulos, vamos a la práctica. En mis prácticas no utilizaré IDE, utilizaré un único archivo fuente y utilizaré el mismo equipo (dotado con Ubuntu Linux) como repositorio y cliente. Por lo tanto, primero, descargaré lo necesario: apt-get install git-core

Primer paso, en rol de “servidor”, creo el repositorio:

$ git init mi_repositorio

Initialized empty Git repository in /home/luciano/mi_repositorio/.git/

En caso de no pasar el último argumento, en mi caso: mi_repositorio, el repositorio se inicializará en el directorio actual.

Ahora, en rol de “cliente”, supongamos que tengo mis desarrollos en este path:

$ pwd
/home/luciano/desarrollo

Si quiero “sincronizar” mi directorio de desarrollo con el repositorio de git, debe hacer un “clone”, así:

$ git clone /home/luciano/mi_repositorio
Cloning into luciano…
done.
warning: You appear to have cloned an empty repository.

Estamos arrancando de cero, por lo tanto el warning es ignorable

El argumento que cambiará del “clone” en el caso que el repositorio se encuentre en otro servidor, será el path del repositorio, que deberá ser antecedido por usuario@host, por ejemplo:

git clone username@host:/path/to/repository

Un repositorio administrador por git cuenta con lo que se denominan tres árboles, el primero, el directorio local (directorio de trabajo). El segundo es un “directorio intermedio” a donde van a parar los archivos que se agregan al proyecto, finalmente el “HEAD” donde reside la última versión confirmada. Ahora, veremos como agregar un archivo al repositorio y como “commitearlo”.

Primero, creo un archivo fuente en mi directorio de trabajo:

$ pwd
/home/luciano/desarrollo
$ cd mi_repositorio
$ touch holamundo.c

Observen lo siguiente, no hay nada que decir:

$ git status
# On branch master
#
# Initial commit
#
# Untracked files:
# (use “git add …” to include in what will be committed)
#
# holamundo.c
nothing added to commit but untracked files present (use “git add” to track)

Ahora, agrego el archivo al repositorio:

$ git add holamundo.c

Finalmente, commit:

$ git commit -m “revision inicial” holamundo.c
[master (root-commit) 2b983d9] revision inicial
Committer: Luciano

Ahora, el estado nuevamente:

$ git status
# On branch master
nothing to commit (working directory clean)

Un último comentario acerca de lo último, el commit quedó registrado con mi usuario (Committer) y mi host luciano@lucid.

Una opción, antes de lo anterior, es setear esos valores de la siguiente forma:

$ git config –global user.name “Juan Del Rio”
$ git config –global user.email juan@delrio.com

Ahora, modifico el fuente y observo el estado de nuevo:

$ echo “/* holamundo program */”> holamundo.c

$ git status
# On branch master
# Changes not staged for commit:
# (use “git add …” to update what will be committed)
# (use “git checkout — …” to discard changes in working directory)
#
# modified: holamundo.c
#
no changes added to commit (use “git add” and/or “git commit -a”)

Hay cambios sin “commitear”, por lo tanto, hago un nuevo commit:

$ git commit -m “agregue encabezado” holamundo.c

$ git status
# On branch master
nothing to commit (working directory clean)

Para terminar (por ahora), si elimino el archivo:

$ rm holamundo.c

$ git status
# On branch master
# Changes not staged for commit:
# (use “git add/rm …” to update what will be committed)
# (use “git checkout — …” to discard changes in working directory)
#
# deleted: holamundo.c
#
no changes added to commit (use “git add” and/or “git commit -a”)

Por lo tanto debo:

$ git rm holamundo.c
$ git commit -m “bye bye adios” holamundo.c
$ git status
# On branch master
nothing to commit (working directory clean)

Por hoy esto es todo, a pesar de que es muy poco y aún no es lo suficiente para compreder las virtudes de un sistema de control de versiones, basta para saber como hacer “altas, bajas y modificaciones”.

En la próxima entrega, quedo comprometido en tratar los “push” a un servidor remoto, trabajar con “branches”, hacer “merges” y un poco más.

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/

Vía: Be Linux my Friend