Para liberar espacio y evitar la descarga e instalación de actualizaciones de esos paquetes que no usamos yo uso este procedimiento:

1.- Confirmar que estamos usando un kernel x86_64 con este comando:

# uname -a | grep x86_64

Eliminar todos los paquetes i386 que también están instalados en versión x86_64:

# yum remove $( for i in ` rpm -q arch=i386 -a` ; do [ `rpm -q $i | wc -l ` -eq 2 ] && echo $i.i386; done )

Por las dudas confirmar que en la segunda columna del listado de confirmación dice i386 o i686 en todos los casos. Además confirmar que la sección “Removing for dependencies:” no contiene paquetes i386 u otros que puedan ser necesarios (usualmente sólo aparece algún paquete i686 que también está instalado en x86_64).

Lo mismo para los i686 que pueden haber quedado:

# yum remove $( for i in ` rpm -q arch=i686 -a` ; do [ `rpm -q $i | wc -l ` -eq 2 ] && echo $i.i686; done )

Entre las alternativas de NAT está siendo bastante nombrado NAT444 aunque tiene problemas para soportar AJAX, muy usado en los sitios web más visitados.

La alternativa de IPv6 implica que todos los servicios de internet sean accesibles también por IPv6, pero las últimas estadísticas indican que existen sólo 353 sitios web en esas condiciones, de un total de 100.000.000 sitios activos; ni hablar de correo y otros servicios. Es más, entre esos sitios web están los 125 sitios de Google.

Queda un año para inventar una alternativa de transición que funcione bien…

La idea es que cada solicitante recibe un mensaje en HTML con dos caritas: una contenta y la otra triste. Es importante minimzar el menú de opciones para apoyar el impulso a hacer clic: si la persona tiene que pensarlo seguramente no va a completar la encuesta.

Si bien inicialmente esperábamos solamente recabar información de primera mano sobre el cumplimiento de cada caso, ahora elevamos la apuesta y le estamos agregando la posibilidad de anotar la razón por la cual no quedó conforme y además pedir que sea notificado un supervisor.

Esto que inicialmente surgió como una forma de obtener información de apoyo al proceso de calidad, ahora se está convirtiendo en un canal directo para llegar a los supervisores…. veremos a dónde nos lleva !

Con el objetivo de aumentar la oferta de servicios y mejorar la disponibilidad y rendimiento de los servicios existentes, fuimos migrando los servicios a servidores Linux virtualizados sobre VMWare.

Si bien se adquirieron licencias de VMWare (y las mismas son realmente necesarias por ejemplo para migrar una máquina virtual “en caliente” de un servidor a otro) la gran mayoría de los servicios se pueden gestionar perfectamente utilizando software gratis:

• VMWare ESXi es gratis
• La interfaz gráfica de administración vSphere es gratis
• La API vim-cmd viene incluida

¿Y hay que comprar licencias? pues, para mover máquinas virtuales en caliente entre servidores se precisa vMotion que no viene gratis. Los servicios de alta disponibilidad tampoco son gratis, pero se puede lograr bastante utilizando la API.

VMWare provee varias API que permiten automatizar la gestión. Nosotros elegimos la interfaz “vim-cmd” que viene incluida en la consola de VMWare ESXi y permite hacer shell scripts para automatizar tareas tales como:

• respaldar una máquina virtual mientras está funcionando
• mover una máquina virtual de un servidor a otro con mínima interrupción del servicio (del orden de medio minuto, las conexiones tcp no se llegan a cortar)
• copiar (clonar) una máquina virtual

Los requemientos para poder utilizar VMWare de esta forma básicamente son:

• Tener hardware de servidores de marca (por ejemplo Dell, IBM, etc.)
• Tener un data storage accesible por todos los servidores (por ejemplo iSCSI)

El script que mueve una máquina virtual de un host a otro requiere que ambos hosts tengan acceso a los archivos de la máquina virtual, y básicamente lo que hace es lo siguiente:

#!/usr/bin/perl
#
# movervm.pl
#
#       Mueve una VM de un host a otro

use strict;
use vm;

if ($#ARGV != 2) {
 print "uso: movervm.pl VM host-actual host-nuevo\n";
 exit 1;
}

my $VM = $ARGV[0];
my $HOST_ACTUAL = $ARGV[1];
my $HOST_NUEVO = $ARGV[2];

my %path = getallvms($HOST_ACTUAL);
if (!defined($path{$VM})) {
 print "ERROR: No esta registrada $VM en $HOST_ACTUAL\n";
 exit 1;
}

print "Moviendo VM '$VM' desde $HOST_ACTUAL hacia $HOST_NUEVO...\n";

print "Suspendiendo $VM en $HOST_ACTUAL...\n";
if (! suspend($HOST_ACTUAL,$path{$VM})) {
 print "ERROR: $VM no se pudo suspender en $HOST_ACTUAL\n";
 exit(1);
}

if (! unregistervm($HOST_ACTUAL,$path{$VM})) {
 print "ERROR: $VM no se pudo quitar del registro de $HOST_ACTUAL\n";
 exit (1);
}

print "Iniciando $VM en $HOST_NUEVO...\n";
if (! registervm($HOST_NUEVO,$path{$VM},$VM)) {
 print "ERROR: $VM no se pudo agregar al registro de $HOST_NUEVO\n";
 if (! registervm($HOST_ACTUAL,$path{$VM})) {
 print "ERROR: $VM tampoco se pudo volver a agregar al registro de $HOST_ACTUAL\n";
 exit(1);
 } else {
 print "ROLLBACK: $VM se volvio a registrar en $HOST_ACTUAL\n";
 exit(1);
 }
}

my %vmid;

print "Obteniendo el nuevo id...\n";
for $_ (1..3) {
 %vmid = getvmids($HOST_NUEVO);

 last if (defined($vmid{$VM}));
 sleep(5);
}

if (!defined($vmid{$VM})) {
 print "ERROR: No se pudo obtener el vmid para $VM en $HOST_NUEVO\n";
 print "Falta iniciarla y configurar autostart\n";
 exit(1);
}

print "Iniciando $VM...\n";
if (! on($HOST_NUEVO,$vmid{$VM})) {
 print "ERROR: No se pudo encender $VM en $HOST_NUEVO\n";
 exit(1);
}

if (! autostart($HOST_NUEVO,$vmid{$VM})) {
 print "ERROR: No se pudo activar autostart para $VM en $HOST_NUEVO\n";
 exit(1);
}

exit(0);

La biblioteca de funciones la tenemos en el archivo vm.pm cuyo contenido es:

#
# vm.pm
#
#       Modulo de funciones auxiliares de interfaz con VMWARE

use strict;

$::USER = 'root';
$::PWD = 'xxx';
$::ARGS="-U $::USER -P $::PWD";

sub getallvms ($) {
 my ($host) = @_;
 my %path;

 open(CMD,"vim-cmd $::ARGS -H $host vmsvc/getallvms|");
 while(<CMD>) {
 next if (/\sName\s/);
 chop();
 @_ = split(/  +/);
 $path{$_[1]} = $_[2]; # $_[1] es el nombre de la VM
 }
 close(CMD);

 return %path;
}

sub suspend ($$) {
 my ($host,$path) = @_;
 my $ok = 1;

 $path =~ s%\[(.*?)\] *%/vmfs/volumes/$1/%;
 open(CMD,"vim-cmd $::ARGS -H $host vmsvc/power.suspend '$path' 2>&1 |");
 while(<CMD>) {
 next if (/^\s*$/);
 next if (/^Suspending/);
 print;
 $ok=0;
 }
 close(CMD);

 if ($ok) {
   my $counter=0;
   while (getstate($host,$path) =~ /on/i) {
     sleep(10);
     if ($counter++ > 12) {
       $ok=0;
       last;
     }
   }
 }
 return $ok;
}

sub unregistervm ($$) {
 my ($host,$path) = @_;
 my $ok = 1;

 $path =~ s%\[(.*?)\] *%/vmfs/volumes/$1/%;
 open(CMD,"vim-cmd $::ARGS -H $host vmsvc/unregister '$path' 2>&1 |");
 while(<CMD>) {
   next if (/^\s*$/);
   print;
   $ok=0;
 }
 close(CMD);

 return $ok;
}

sub registervm ($$;$) {
 my ($host,$path,$name) = @_;
 my $ok = 1;

 if (!$name) {
   $path=~ m%([^/]+)\.vmx%;
   $name = $1;
 }
 $path =~ s%\[(.*?)\] *%/vmfs/volumes/$1/%;
 open(CMD,"vim-cmd $::ARGS -H $host solo/registervm '$path' '$name' 2>&1 |");
 while(<CMD>) {
   next if (/^\s*$/);
   print;
   $ok=0;
 }
 close(CMD);

 return $ok;
}

sub getvmids {
 my ($host) = @_;
 my %vmid;

 open(CMD,"vim-cmd $::ARGS -H $host vmsvc/getallvms|");
 while(<CMD>) {
   next if (/\sName\s/);
   chop();
   @_ = split(/  +/);
   $vmid{$_[1]} = $_[0];
 }
 close(CMD);

 return %vmid;
}

sub on ($$) {
 my ($host,$path) = @_;
 my $ok = 1;

 $path =~ s%\[(.*?)\] *%/vmfs/volumes/$1/%;
 open(CMD,"vim-cmd $::ARGS -H $host vmsvc/power.on '$path' 2>&1 |");
 while(<CMD>) {
   next if (/^\s*$/);
   next if (/^Powering/);
   print;
   $ok=0;
 }
 close(CMD);

 if ($ok) {
   my $counter=0;
   while (getstate($host,$path) !~ /on/i) {
     message($host,$path,0,1) || sleep(10);
     if ($counter++ > 12) {
       $ok=0;
       last;
     }
   }
 }
 return $ok;
}

sub autostart ($$) {
 my ($host,$vmid) =@_;

 open(CMD,"vim-cmd $::ARGS -H $host hostsvc/autostartmanager/update_autostartentry $vmid 'PowerOn' ' -1' ' -1' 'SystemDefault' ' -1' '
systemDefault' |");
 while(<CMD>) {
   chop();

   if (/Updated AutoStart order/) {
     return 1; # OK
   }
 }
 close(CMD);
 return 0; # ERROR
}

sub message ($$$$) {
 my ($host,$path,$messageid,$response) = @_;
 my $ok = 1;
 my $found = 0;

 $path =~ s%\[(.*?)\] *%/vmfs/volumes/$1/%;

 open(CMD,"vim-cmd $::ARGS -H $host vmsvc/message '$path' $messageid 2>&1 |");
 while(<CMD>) {
   next if (/^$/);
   if(!/No message/) {
     $found = 1;
     last;
   }
 }
 close(CMD);

 if ($found) {
   sleep 1;
   # Envio la respuesta
   open(CMD,"vim-cmd $::ARGS -H $host vmsvc/message '$path' $messageid $response 2>&1 |");
   while(<CMD>) {
     next if (/^\s*$/);
     print;
     $ok=0;
   }
 close(CMD);
 }

 return (!$found || $ok);
}

sub getstate ($$) {
 my ($host,$path) = @_;
 my $estado;

 open(CMD,"vim-cmd $::ARGS -H $host vmsvc/power.getstate '$path' |");
 while(<CMD>) {
   next if (/Retrieved runtime info/);
   chop();
   if (/Powered (.*)/) {
     $estado=$1;
   } elsif (/Suspended/) {
     $estado="Suspended";
   }
 }
 close(CMD);

 return $estado;
}

La descripción del proyecto según el sitio oficial:

Cooperative Linux es el primer método funcionando, gratuito y de fuente abierta que permite correr Linux en Microsoft Windows de forma nativa.

Cooperative Linux es una adaptación del Kernel de Linux que le permite correr de forma cooperativa junto a otro sistema operativo en una misma computadora. Por ejemplo permite usar aplicaciones Linux en Windows/2000 sin requerir software de virtualización como VMWare.

En la imagen estoy usando firefox de Linux en mi escritorio Windows, y eso me permite hacer pruebas de compatibilidad de las aplicaciones sin tener que reiniciar el PC con Linux (dual boot).

Además, el proyecto andLinux tiene una versión de CoLinux que ya viene con un Ubuntu completamente configurado.

# Uruguay
# From Paul Eggert (1993-11-18):
# Uruguay wins the prize for the strangest peacetime manipulation of the rules.

En fin, ahora que hace ya tres años que tenemos una regla fija, vale la pena configurar los PCs y servidores para que el cambio de hora se realice automáticamente.

En sistemas operativos nuevos no es problema, pues la definición de la zona horaria ya viene incluida en las actualizaciones, pero por ejemplo en Windows 2000 no es así.

Hoy encontré que haciendo un archivo “montevideo.reg” con el siguiente contenido:
Windows Registry Editor Version 5.00

[HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\Windows NT\CurrentVersion\Time Zones\Montevideo Standard Time]
"Display"="(GMT-03:00) Montevideo"
"Dlt"="Montevideo Daylight Time"
"TZI"=hex:b4,00,00,00,00,00,00,00,c4,ff,ff,ff,00,00,03,00,00,00,02,00,02,00,00,\
00,00,00,00,00,00,00,0a,00,00,00,01,00,02,00,00,00,00,00,00,00

Luego cuando incorporamos en la registry (haciendo doble clic sobre el archivo) nos queda definida una nueva zona horaria (Montevideo Standard Time) que se puede elegir haciendo doble clic en el reloj del sistema en la lengüeta “Zona horaria”; y listo !

La foto no es muy linda, pero igual quedó publicada acá: http://www.schmap.com/madrid/tours_tour4/#p=1401D02&i=1401D02_10.jpg

Hace tiempo que no ponía fotos de ellos.

Lo que me pareció muy interesante es que en la página con la descripción detallada de un libro ponen un recuadro con enlaces a las librerías locales que lo pueden vender en línea, y entre ellas está entrelibros!!

Qué grande Google.

Me sirvió para detectar un error en mis cálculos ¡por el cual iba a pagar de más!