Objectives

1. Simple principle of work.
2. Migration painless process, people should be able to copy existence code and put on the worker and it should work.
3. Easy scalability, just add more workers on need.
4. Provide a simple and effortless way to deploy application across many servers.

Some concepts

1. Client: The project has a list of workers, he choose one randomly and query a function or queue a job.
2. Worker: C or C++ application with PHP embed, which listen a TCP port (probably 25887). The work can accept request from any where, but only a single IP (from the master process) can submit and deploy
3. Master process: PHP web page, where the sysadmin can upload PHP code and “deploy” (submit to every worker).

System overview

The graphic above show how the system will look like, the clients (PHP scripts that runs on the webserver) can connect to any worker and request a function or queue a procedure. In the case of a function the client spects and response, otherwise it will not. The master process is the only one allowed to submiy PHP code to the workers, with this the system has an really easy way to deploy applications.

Adventages

1. Single point of source code distributions.
2. There is not a manager process, the client speak directly to a worker, that keep it really simple and fault tolerant. In traditional models if the manager crash, nothing works.
3. I am plannig to add a Cache layer on the client, to avoid call same functions with same parameters, if the function is cacheable, in order to reduce the network latency.
4. It can be used to process large amount of datas in parallel, as hadoop does.

Este post va dedicado a mi amiga Piojita, que gracias a sus ganas de aprender tengo ánimos e ideas para escribir acá, ojalá puedan ser de utilidad a los que por miedo no preguntan

En estos días está muy de moda todo lo que sea MVC, que no es otra que escribir aplicaciones en tres niveles, Modelo (acceso a los datos), Vista (la presentación al usuario) y el Controlador (Encargada de los eventos, y en muchos casos es el nexo entre el modelo y la vista). Como Rasmus dice en su post The non-framework PHP MVC Framework, que en su época trajo polémica, utilizar frameworks tiene ventajas y desventajas, para mi gusto más desventajas que ventajas.

Primero que nada los frameworks webs convencionales, realizan muchas tareas automáticamente, y abstrae muchos detalles al programador que si bien ahora un montón de tiempo, no es efectiva, ya que asúme varías cosas por defecto. Cuando digo que no es efectiva hablo de que lo que se gana en tiempo, se pierde en el rendimiento de la aplicación, ¿de que nos sirve hacer una aplicación web en 5 minutos si sólo puede tener hasta 5 visitas en simultáneo? ¿No sería acaso mejor tardar 40 minutos y que soporte 30 visitas en simultáneo?, quizá  parezca una  exageración pero se acerca mucho a la realidad.

No estoy diciendo que utilizar frameworks es algo malo, depende de las necesidades del sitio web a ser realizado. <ironic>Si fuésemos radicales cada uno escribiría programas en asembler que corra con en nuestro propio sistema operativo,</ironic>

Mi idea con esta entrada es mostrar que no sólo utilizando frameworks que fuerzan a uno a utilizar uno u otro modelo de programación es posible escribir aplicaciones web en poco tiempo manteniendo la simpleza y mantenibilidad del código como primer meta. En otras palabras escribiré, o al menos esbozaré, un mini-framework MVC en PHP.

Modelo

El modelo es, probablemente, la parte más delicada del sistema ya que es la encargada de interactuar con las bases de datos. Siempre es bueno diseñar una buena API de datos persistentes, para no tener que escribir SQL en todas partes. Aparte de mantener el código ordenado, ayuda a la legibilidad del mismo, ya que sabemos si hay un error en base de datos, sabremos con seguridad de que parte del código hay que parchar.

A mi me gusta usar clases para definir una tabla y relaciones, sería algo así como lo siguiente (no es código funcional, solo un ejemplo).

<?php
class Users {
    function GetAll() {
        return $this->Select();
    }

    function Select($params=array()) {
        $sql = "SELECT * FROM users";
        if (is_array($params) && count($params)) {
            $where=array();
            foreach($values as $col=>$val) {
                $where[] = "$col='".addslashes($val)."'";
            }
            $sql .= " WHERE ".implode(" and ",$where);
        }
        return db_exec($sql);
    }

    function Update($id,$values) {
        if (!is_numeric($id)||!is_array($values)||!count($values))
            return false;
        $id  = addslashes($id);
        $cols = "";
        foreach($values as $col=>$val) {
            $cols .= "$col='".addslashes($val)."',";
        }
        $cols[strlen($cols)-1] = ' '; /* borrar el ultimo , */
        $sql = "UPDATE users SET $cols WHERE id = $id";
        db_exec($exec); /* call some db */
    }
}

?>

Algo un poco más automático es esta parte sería grandioso, es un poco molesto escribir mucho SQL, especialmente para las relaciones y esas cosas. Actualmente estoy trabajando, con un amigo brasilero, en una implementación de ActiveRecord (con API similar al de AppEngine) para PHP 5 (es que quiero hacer algo útil también con PHP5). No voy a dar más detalles hasta que esté terminado, pero doy la primicia, se podrán definir relaciones en las clases. Ejemplo:

<?php
class Author extends XXORM {
    function data() {
        $this->name = DB::String(array("size"=>50,"required"=>true));
        $this->book = DB::Relation("Books",DB::MANY);
    }
}

class Books extends XXORM {
    function data() {
        $this->author = DB::Relation("Author",DB::ONE);
        $this->title = DB::String(array("required"=>true,"size"=>50));
    }
}
?>

El proyecto, creara las estructuras de las tablas (si se ejecuta en modo development), también vendrá con una API para extender utilizando Hooks, especial para el cacheado de consultas y demás. Se podrán crear filtros de validaciones por campos, entre otras caracteristicas, si están interesados pueden seguirme twitter

La vista

Una de las características de PHP es que puede ser mezclada con HTML, pues entonces ¿para que el overhead de utilizar un template engine?

<html>
<head>
    <title><?php echo $title?></title>
</head>
<body>
    <?php foreach($users as $user): ?>
        <?php echo $user?>
    <?php endforeach;?>
</body>
</html>

Algunos consejos, evitar los short tags(<?=, <?), evitar utilizar las llaves ({}) para ello utilizar los : y los end*; asi como el ejemplo.

El controlador

El controlador no es nada mas que una función que la mayoría del tiempo llama a la vista y al modelo, aunque no se limíta solamente a eso (ej. enviar un e-mail, subir un archivo de un a ftp, etc).

<?php

function user_controller($params) {
    if (
            !is_array($params) ||
            !isSet($params[1]) ||
            !is_numeric($params[1])
        )
            return false;
    /* llamamos el modelo */
    $dbu   = new User;
    $users = $dbu->Select(array("id"=>$params[1]));
    /* incluimos la vista */
    /* la variable $users es visible para vista */
    include("vista.php");
}

?>

Ruteo de URL a Controladores

<?php
class Router {
    function AddRoute($reg_expr,$action) {
        if (!is_callable($action) && !is_file($action))
            return false;
        $this->route[$reg_expr] = $action;
    }

    function FindAction($url) {
        $routes = & $this->route;
        foreach((array)$routes as $route) {
            extract($route);
            if (preg_match($reg_expr,$url,$params)) {
                $ret = true;
                if (is_callable($action))
                    $ret = call_user_func($action,$params);
                else
                    include($action);
                return true;
            }
        }
        if (!isset($ret) && !$ret)
            $this->err();
        return false;

    }

    function err() {
        header("HTTP/1.1 404 Not Found");
        include("not-found.php");
    }
}

?>

Poniendo todo en orden

Hasta ahora vimos el MVC, separados, ahora ¿como juntamos todo eso?, pues sería algo así

<?php
/* la clase de ruteo URL -> Controlador*/
include("routes.php");
/* los modelos de datos */
include("model.php");
/* controladores */
include("controllers.php");

/* */
$router = new Router;
/* ruta hacia un controlador */
$router->addRoute('/user\/([0-9]+)$/i',"user_controller");
/* ruta hacia una vista, por no se necesite un */
/* controlador */
$router->addRoute("/","principal.php");
#... Demas reglas

/*
 * buscamos el controlador, basado en el URI,
 * suponiendo que tenemos el URL Rewrite activado
 * un uri com "/user/11" haria match, y se ejecutaria
 * un controlador.
 */
$route->FindAction($_SERVER['REQUEST_URI']);
?>

Como verán, un poco de orden en la forma de programar, utilizando un mini-framework, que en realidad son buenos hábitos a la hora de programar, fácilita nuestro trabajo (y de los que mantendrán nuestro código), a la vez de hacerlo efecto (¿para que derrochar valiosos ciclos de procesador?).

Execute the follow command as root,

$ kill -9 `lsof -t /dev/snd/*  2> /dev/null`

Warning, the previous command will close all the audio programs (i.e xmms, amarok, etc).

I love UNIX, I can’t figure out live without it.

#!/bin/bash
#el archivo de salida
SALIDA="concat.avi"
#  si tienen poco espacio en disco pal-vcd es mejor
ARGS="-target pal-dvd"
# archivo temporal, si o si tiene que ser mpg
TMP="concat.mpg"
> $TMP

for i in "$@"
do
    ffmpeg -i "$i" $ARGS - >> $TMP
done
ffmpeg -i "$TMP" $SALIDA
rm -rf $TMP

Su utilización es sencilla

$ ./concat.sh video-part-1.avi video-part-2.avi video-part3.avi

Hoy en día necesité  autenticar un Squid-cache contra el Active Directory de Windows, y como a la primera no me funcionó el helper LDAP que viene por defecto escribí un pequeño script en python que funciona, capaz a alguien le sea útil.

#!/usr/bin/env python  

import ldap, sys
from syslog import *

LDAP_SERVER='ldap://' + sys.argv[1]
try:
    ldap_client = ldap.initialize(LDAP_SERVER)
except:
    syslog(LOG_ERR,"Couldn't connect to the LDAP")
    sys.exit()

while (1):
    try:
        (user,passwd) = sys.stdin.readline().strip().split(" ")
        ldap_client.simple_bind_s(user,passwd)
        syslog(LOG_INFO,"%s login" % user)
        # Login success
        print "OK"
    except:
        syslog(LOG_INFO,"%s login failed" % user)
        # Sorry, an error
        print "ERR"
        sys.stdout.flush() # Requerido en algunas distros
ldap_client.unbind()

Es un simple script como lo ven, puede estar escrito en cualquier lenguaje (que tenga stdin y stdout) como PHP, C, Ruby, Haskell, Bash, pero elegí python para mostrar que tambíen hablo otro lenguajes (aparte de PHP y C). Tambíen pueden autenticar contra cualqueir cosa (ejemplo contra una DB como hacen acá) y por ejemplo asignar usuario por tiempos. Por último, para configurar el helper (asumiendo que el 192.168.1.1 es el servidor de ActiveDirectory):

auth_param basic program /path/to/login.py 192.168.1.1

# Aquí vi que algunos muggles que ponian 20, es muy alto, y no vale la pena
# a no ser que se tenga miles de usuarios.
auth_param basic children 5 

auth_param basic realm Type your password
# tiempo que será valido el login, para no hacer
# overhead tendría que ser un tiempo razonable
auth_param basic credentialsttl 5 minutes

Espero que mis días como sysadm lleguen a su fin, extraño los días de programar para vivir, no es lo mismo que pase a ser solo un hobbie.

Lo que me gusta de SQLite es que su API es muy sencilla y que cuanta con cosas para los perezosos (”sqlite3_execute”) y con cosas para personas que piensan que lo primordial es el performance. Un código vale más que mil palabras, miren un pequeño ejemplo de SQLite…

/**
 * Coded by crodas,
 *
 * The author disclaims the copyright of this code.
 */
#include <stdio.h>
#include <stdlib.h>
#include <sqlite3.h>

int table_exists(sqlite3 * dbh, const char * table) {
    sqlite3_stmt* pStmtPrep;
    int rc,exists;
    /* preparamos el SQL a ejecutar, muy util para evitar SQL injections */
    rc=sqlite3_prepare(dbh,"select * from sqlite_master where type='table' and name=?",-1 /* null terminated str*/, &pStmtPrep,NULL);
    if (rc!=SQLITE_OK) {
        printf("This is an SQL bug %s",sqlite3_errmsg(dbh));
        exit(-1);
    }

    /* asignamos a la primera variabla (?) el valor de table*/
    sqlite3_bind_text(pStmtPrep,1,table,-1,0);

    /* ejecutamos */
    rc = sqlite3_step(pStmtPrep);
    switch(rc) {
        case SQLITE_ERROR:
        case SQLITE_BUSY:
            printf("Database locked or unknown error");
            fflush(stdout);
            exit(-1);
            break;
        case SQLITE_DONE:
            exists = -1; /* no existe */
            break;
        case SQLITE_ROW:
            exists = 1; /* existe */

    }

    /* a liberar memoria! */
    sqlite3_finalize(pStmtPrep);
    return exists;
}

int main() {
    sqlite3 *  dbh;
    int rc,i;
    sqlite3_stmt* pStmtPrep;

    if (sqlite3_open_v2("test.db",&dbh,SQLITE_OPEN_READWRITE | SQLITE_OPEN_CREATE,0)!=SQLITE_OK) {
        printf("Can't  open db, please check permissions on this folder. %s\n",sqlite3_errmsg(dbh));
        return -1;
    }

    /**
     *  Hice una pequenha funcion que ve si existe.
     *  lo bueno de la funcion es que muestra el primer ejemplo
     *  el SQLPrepare, y muestra como saber si la consulta
     *  tiene resultado o no
     */
    if (table_exists(dbh,"testing")==-1) {
        printf("Table doesn't exists,execute\n");
        /* tabla sencilla, utilizo exec porque no espero resultado */
        sqlite3_exec(dbh,"create table testing (id int, text varchar(250))",0,0,0);
        /* sql preparada para el insert */

        int data_id[] = {5,5,5,8,0}; /* el ID no es PK, en la vida real seria PK*/
        const char*  data_data[] = {"Some text","Another text","foobar","This is the 8 text",0};
        rc=sqlite3_prepare(dbh,"insert into testing values(?,?)",-1, &pStmtPrep,NULL);
        /* no controlo nada porque ya mostre en la funcion anterior como controlar errores */
        for(i=0;;i++) {
            if (data_id[i] == 0) break;
            /* cambiamos ? ? por sus valores */
            sqlite3_bind_int(pStmtPrep,1,data_id[i]);
            sqlite3_bind_text(pStmtPrep,2,data_data[i],-1,0);

            /* ejecutamos */
            rc=sqlite3_step(pStmtPrep);
            /* se tendria que controlar la salida*/

            /* ya que no hay ciclos, para cambiar los parametros */
            /* debemos reinicar al Statement */
            sqlite3_reset(pStmtPrep);
        }

        sqlite3_finalize(pStmtPrep);
    }

    /* ahora queremos los datos con id 5,6,7,8 */
    int data[] = {5,6,7,8,0};
    char * text;
    rc=sqlite3_prepare(dbh,"select * from testing where id=?",-1 /* null terminated str*/, &pStmtPrep,NULL);
    /* no controlo nada porque ya mostre en la funcion anterior como controlar errores */
    for(i=0;;i++) {
        if (data[i] == 0) break;
        /* asignar valor a ? */
        sqlite3_bind_int(pStmtPrep,1,data[i]);
        /* mientas haya resultado */
        while (sqlite3_step(pStmtPrep)==SQLITE_ROW) {
            text = sqlite3_column_text(pStmtPrep,1); /* id = 0, text=1 */
            printf("%d: %s\n",data[i],text);
        }

        /* reinicar el stmt */
        sqlite3_reset(pStmtPrep);
    }

    /* */
    sqlite3_finalize(pStmtPrep);

    sqlite3_close(dbh);
}

Lo que me gusta es que tenemos a toda una base de datos relacional en nuestro programa, y si de rendimiento se trata se puede hacer “prepare” de todas las consultas SQL al principio del programa y luego ir ejecutando, no es cosa complicada,  se ahoraría un montón de tiempo y procesador.

Otra cosa que me gusta mucho es que fácilmente extendible, una vez necesitaba una función para comprimir y descomprimir (la función compress y decompress del MySQL), envíe mi consulta en la lista de SQLite, y Dr. Hipp me respondío lo siguiente:

/*
** SQL function to compress content into a blob using libz
*/
static void compressFunc(
  sqlite3_context *context,
  int argc,
  sqlite3_value **argv
){
  int nIn, nOut;
  long int nOut2;
  const unsigned char *inBuf;
  unsigned char *outBuf;
  assert( argc==1 );
  nIn = sqlite3_value_bytes(argv[0]);
  inBuf = sqlite3_value_blob(argv[0]);
  nOut = 13 + nIn + (nIn+999)/1000;
  outBuf = malloc( nOut+4 );
  outBuf[0] = nIn>>24 & 0xff;
  outBuf[1] = nIn>>16 & 0xff;
  outBuf[2] = nIn>>8 & 0xff;
  outBuf[3] = nIn & 0xff;
  nOut2 = (long int)nOut;
  compress(&outBuf[4], &nOut2, inBuf, nIn);
  sqlite3_result_blob(context, outBuf, nOut2+4, free);
}

/*
** An SQL function to decompress.
*/
static void uncompressFunc(
  sqlite3_context *context,
  int argc,
  sqlite3_value **argv
){
  unsigned int nIn, nOut, rc;
  const unsigned char *inBuf;
  unsigned char *outBuf;
  long int nOut2;

  assert( argc==1 );
  nIn = sqlite3_value_bytes(argv[0]);
  if( nIn<=4 ){
    return;
  }
  inBuf = sqlite3_value_blob(argv[0]);
  nOut = (inBuf[0]<<24) + (inBuf[1]<<16) + (inBuf[2]<<8) + inBuf[3];
  outBuf = malloc( nOut );
  nOut2 = (long int)nOut;
  rc = uncompress(outBuf, &nOut2, &inBuf[4], nIn);
  if( rc!=Z_OK ){
    free(outBuf);
  }else{
    sqlite3_result_blob(context, outBuf, nOut2, free);
  }
}

/* Make the functions above accessible to SQLite as follows:
*/
  sqlite3_create_function(db, "compress", 1, SQLITE_UTF8, 0,
     compressFunc, 0, 0);
  sqlite3_create_function(db, "uncompress", 1, SQLITE_UTF8, 0,
     uncompressFunc, 0, 0);

Como vieron no es cosa de otro mundo, muy sencillo, y ya extendimos SQLite!. Ahora que estaré de vacaciones empiezaré a jugar con el SQlite VFS, veremos que sale…

Last week I was “pinged” by two Brazilians friends (Augusto and Bruno “Porkaria”) to follow a funny chain of blog posts, and I read a lot about this on several blogs and it is funny, I never thought that I’d could be included in the circle, so now I’m in, so here I come (I apologise, probably I am not very interesting).

1. I start coding with Visual Basic 5 (my dark side), then I switch to PHP3.
2. I love Metal Music (heavy, death, black, heavy), and to me there is not other kind of music.
3. I disliked PHP5 ‘coz it’s look as a Java’s ripe off, but now I am trying out, and it looks nice, probably I will drop off PHP4 soon.
4. I’d like to be a designer, but it’s really really hard, I know CSS and the basic of GIMP, but still I don’t have inspiration,
5. I want to work outside this country ASAP, and no one wants to hire me, I think I need to finish my University first,
6. I am coke addict, I can’t live without it (1l per day), I need to leave it ASAP,
7. I don’t like beer nor Whisky, I prefer Sprite + sugar + Vodka.

Now let’s choose seven people (I don’t warranty they will follow this chain):

• Richardo Galli: He is a PHP/Ninja, a great GTalk friend, and the creator of Menéame.net, He is the second guy that I met with a profile in Wikipedia (English && Spanish).
• Manuel Lemos: The greatest PHPDev I meet in person, I don’t think he will write about this (usually he is busy), but let’s try.
• Matias Insaurralde: He is a “Railer” but I am PHPzing him… soon he will be a great PHPdev.
• Felipe Ribeiro: A great friend, he taught me ’bout the RESTful in one great talk in ConaPHP 2008.
• Pablo Castillo: Great developer, great friend… together we’re planning to move this poor country.
• Matt Mullenweg: Everybody knows him, I meet him at the Latinoware 2008, very nice person.
• Matias Montes: I meet him at the Latinoware 2008, great speecher, great PHPdev.

I have several other friend, but probably they already done this, or they don’t have a blog (as my friend Cristian Medeiros, come on man open a blog!)

Rules are quite simple:

- Link your Original tagger(s), and list these rules on you blog

- Share seven facts about yourself in the post - some random, some weird.

- Tag seven people at the end of your post by leaving their names and the links to their blogs.

- Let them know they’ve been tagged by leaving a comment on their blogs and/or Twitter.

Algunos de mis beta testers (osea gtalk-friends) creyeron al principio que solo utilizaba el API de Google, cosa que ni sabia que existía. Afortunadamente hace algún tiempo atrás pude ver la luz al leer el Paper que cambio mi forma de pensar, desde ahí me tuve la idea de armar un como languess.com, hasta que finalmente le gané a la pereza y ahí lo tienen.

Obviamente es casi imposible que sea perfecto, pero según mis pruebas detectaba bastante bien. Claro que si se equivoca se le puede enseñar y la próxima vez que genere los n-gramas aprenderá mejor.

Ahora mismo languess aprendió Español, Ingles, Francés y Portugués teniendo como ejemplo la Santa Biblia (obviamente en cada idioma citado), y por su parte Alemán y Esperanto gracias a los ejemplos proveídos por Matias que hizo un script en 5 min. (probablemente en ruby) que extrae textos de Wikipedia. Si alguien tiene textos puede enviarme a mi mail asi Languess puede aprender mas y mas idiomas (no se necesitan muchos textos de ejemplos, pero mientras mas mejor), seria genial si alguien puede enviarme algo de Guaraní.

Para el futuro queda afinar el detector para que sea casi perfecto, para ello creo que tengo que afinar el método de aprendizaje, pero hay una sola forma de saber, con las pruebas de los visitantes.

Saludos a todos, y feliz año 2009.

A simple vista parece una simple instalación del los Planetarios (ej: Planet PHP), pero no, aunque el diseño es totalmente copiado (como podrán ver, no soy diseñador.. diseñadores.. donde estan??) el código no tiene nada que ver con el Planetario. Se preguntaran por que… y simplemente porque yo quería usar mis clases y armar algo 100% paraguayo y que funcione con PHP4 y PHP5. Además ya que programé toda la página es sencilla extender.

Ahora lo que estoy viendo que haría falta es organizar los posts por temas, ciudades, departamentos e idiomas, para que sea más útil, comentarios y sugerencias son bienvenidos.

Los fuentes del sitio son está muy beta, pero si la gente está interesada puedo estructurar mejor y liberar como Open Source (claro como BSD).

PyGosfera es el nombre, como se darán cuenta no soy muy creativo, también se aceptan sugerencias para nombre nuevo…

Saludos y que lo disfruten.

Ahora les presento mi nuevo juguete read2.us (Read to us), un página web que hace text to speech, es decir genera un mp3 apartir de un texto ingresado. Ahora mismo son soportados el Español y el Inglés.

Aquí les dejo una pequeña prueba de como suena. Obviamente faltan algunos detalles para el parseado mismo del texto, es decir para que lea correo electrónico, páginas webs y demás detalles que estare terminando lo más rápido posible.

Luego si el proyecto tiene la atención y el feedback que estoy esperando crearé algún webservice para la generación de audios de textos, para por ejemplo poner a algún diario, blogs o cualquier otro sitio. Así los que tienen visión disminuida podrán disfrutar de la web.

Está por demás decir que el servicio es beta, y que tendrá algunos inconvenientes, pero daré lo mejor de mí para que el proyecto siga adelante.

He aquí el porque escribo Open Source…, para que miles de personas utilicen mis códigos. Aquí esta una prueba de ello, un popular (casi 20mil descargas) plug-in de Wordpress.

Grande Photo Xhibit

Gracias a Sarita por avisarme.

Anteriormente mencione que Amazon S3 es una solución barata, muchas veces barata no es suficiente (especialmente si pagas a Amazon S3 una fortuna por otros sitios). Luego de pensar, y pensar en un medio de almacenamiento mas o menos seguro y gratis de ser posible, se ocurrió que tengo bastante espacio ocioso en mi gmail (65% para ser exacto). La única limitación es que el backup generado tiene que ser menor de 20MB. El único problema que ahora surge es que Google podría leer nuestros backups y ahí obtener valiosa información sobre nuestro sitio web, base de dato u otra cosa que este contenida en el backup,

Para solucionar ese problema podríamos usar encriptación, de manera que nadie pueda ver el contenido del archivo sin una clave.

Aqui les presento el script que yo utilizo para hacer los backups de mis servidores.

#!/bin/bash -x
MAIL=foobar@gmail.com #Obviamente, no solo funciona con @gmail.
SQL=/tmp/tables.sql
DATE=`date '+%F'`

# Password que es un MD5
# de un string que tiene la fecha,
# cada dia, tiene un password unico
echo "password con $DATE " > /tmp/foo
PASS=`md5sum /tmp/foo |  sed "s/ .*//g"`
rm /tmp/foo

# backup de mysql.
mysqldump -u root --all-databases | bzip2  | openssl des3 -salt -k $PASS | dd of=$SQL
# Ahora comprimimos
tar cfj  -  /www/foobar.com | openssl des3 -salt -k $PASS | dd of=foobar.com-$DATE.bin
# /etc
tar cfj - /etc/  | openssl des3 -salt -k $PASS | dd of=etc-$DATE.bin

# Ahora enviar los mails
echo  | mutt -s "[backup] $DATE foobar.com " $MAIL -a foobar.com-$DATE.bin
echo  | mutt -s "[backup] $DATE /etc" $MAIL -a etc-$DATE.bin
echo  | mutt -s "[backup] $DATE MySQL" $MAIL -a $SQL
rm $SQL

Para restaurar el backup simplemente hay que ejecutar el siguiente script. Lo importante es proveer siempre la clave correcta, que cambia para cada día (utiliza la fecha). Sin la clave es literalmente imposible que recuperemos el contenido, de ahi la importancia de no olvidar la clave.

#!/bin/bash -x

dd if=$1 |openssl des3 -d -k $3 | dd of=$2

Para restaurar el backup simplemente debe realizar lo siguiente:

$ restore archivo-encriptado archivo-salida-desencriptado clave

Si se preguntan cuan seguro es el encriptado?, pues la respuesta es suficiente para que yo ponga informacion real sobre una de mis tarjetas de creditos con algunos dolares (sobrantes del Google Summer of code) en un sitio de descarga para que la gente intente romper la seguridad. Si deseas intentar puedes bajarte de aqui.

Para aquellos desconocedores de la tira; Raulito es un friki con unos 30 años amante de Debian GNU/Linux y con la desgracia de que las iniciales de su nombre son R P M (Raúl Peñáez Martinez), que no puede encajar en la sociedad (¿O la sociedad no encaja con él?). Sus padres frustrados de su anómalo hijo (el cual reiteradas veces piensa y actúa como un kernel de Linux) tratan de cambiarlo e integrarlo a la sociedad, por ejemplo llamando a un cura (del opus dei) para que lo guíe por el buen camino. Al final éste termina creyendo que esta poseído y que es un ferviente y apasionado homosexual.

Si se preguntan porque no dudé ni un segundo en bajarte “la temporada”, vean porque:

Si quieren bajarse las demás tiras, aquí están de la tira 1 hasta el 95.

Si alguien quiere también tengo todas las bilo y nano.

Baratos

Para la mayoría de los sitios webs no se justifica un servidor dedicado y un shared hosting que pequeño, entonces ¿cuál sería el punto medio?, ahí cuando entran en juego las VPS. Básicamente las VPS son máquinas virtuales en donde tenemos acceso total, casi todos utilizan Xen aunque personalmente me encanta el Linux-VServer (esto es totalmente irrelevante en este artículo), hablando mal y rápido son como máquinas dedicadas con menores recursos y lo más importante mucho menos precio.

Yo utilizo Linode, y realmente no me puedo quejar de su servicio, pero existen varios otra opciones en el mercado.

Seguros

La seguridad es un tópico bastante extenso, y básicamente es una buena práctica. Ya que nadie no velará por la seguridad de nuestro server, más que nosotros mismos tenemos que tomar algunas medidas, básicamente ocultar los detalles de nuestro servidores. En todos los ataques “hackers” que fui parte (siempre como victima, en algún trabajo) fue por que el “atacante” conocía como funcionaba el servidor (ex-funcionario) o por culpa del administrador del servidor que dejó las configuraciones por defecto.

Algunas de las buenas prácticas son las siguientes:

• Secure Shell (SSh): Esta herramienta es fundamental a la hora de conectarnos al servidor y administrarlo remotamente, al mismo tiempo de ser necesario puede volverse peligrosa, aunque es cierto es difícil de vulnerar (casi siempre por error humano, como una contraseña sencilla), pero en caso de vulnerar los resultados serán fatales.
  • Desabilitar el root login.
  • Utilizar contraseñas dificiles de adivinar (ej: 12 caracteres, mezclas entre mayusculas, minusculas y números) y anotar la contraseña. Para utilizar la anotación a cada vez que se necesite conectarse al servidor, se podría en una máquina personal, generar claves (ssh-keygen) y luego copiar las claves (ssh-copy-id) al servidor así a cada vez que nos hagamos login en el servidor, este no nos pedirá contraseña.
  • Escuchar en un puerto distinto del puerto 22, es preferible escuchar en un puerto superior al 20000 así sería un poquito más complicado de detectar con con algún scanner de puertos.
  • Guardar Log de los login fallidos.
  • Vía firewall permitir el acceso al SSH de algunos rangos de IPs si es posible.
• Siempre tener un firewall (IPtables o ipfw).
• Evitar el DoS attack: Ricardo Galli, creador de Menéame (y mi amigo vía talk), escribió en su blog, un interesante artículo de como él evitó el ataque de DoS en su sitio, bastante interesante.
• PHP:
  • Nunca mostrar los errores al usuario, siempre hacer logging de los errores y mostrar al usuario alguna página con información genérica del error sin datos técnicos.
  • Limitar los recursos como memoria RAM, tamaño máximo de las peticiones GET, POST, tiempo máximo de ejecución, etc.
• MySQL:
  • El mysqld debe escuchar 127.0.0.1 si la base de datos se encuentra en la misma máquina que el servidor web, en caso contrario siempre asegurarse que este en una red privada, nunca colocar en una red pública escuchando 0.0.0.0
• Backup: realizar backup de los datos (códigos fuentes, dump de la base de datos) y configuraciones (/etc/, /var/logs/ y otros) frecuentemente como máximo a cada día, y copiar en otro servidor, si no se cuenta con otro servidor, una alternativa efectiva y barata es colocar en Amazon S3.
• Generalidades: limitar los recursos de los servicios, siempre tener logs de los deamons.

Eficientes

Como decía en mi articulo anterior (como mejorar el rendimiento de una web), si deseamos tener un servidor para atender un gran número de visitas lo más importante despues de la buena práctica de programación era tener un servidor web efectivo, parte de la efectividad era separa las consultas dinámicas y las estáticas hacia diversos servidores. Esto no es problema si hacemos las aplicaciones from scratch, pero que pasaría si por ejemplo queremos instalar una aplicación Open Source (ej: wordpress), cambiar las direcciones de los archivos estáticos hacia otro dominio sería un poco trabajoso (todos sabemos que no sería un problema que con wp, solo es un ejemplo). La solución más simple sería un reverse proxy que redirija la petición dependiendo de que si el recurso requerido es estático o dinámico.

Ahí es cuando entra en juego el NGinx ya que aparte de ser un increíble webserver, también es reverse proxy entre otras cosas. La configuración será la siguiente.

Aquí va la configuración.

# El usuario va a ser nginx, siempre es importante
# ejecutar como usuario sin privilegio.
user  nginx;
# número de procesos "workers" que se encargaran de
# atender a la peticiones entrantes.
worker_processes 2;
# log
error_log  logs/error.log;
# pid, útil para reiniciar el "servicio"
pid        logs/nginx.pid;

events {
    # procesos que se encargaran de responder la petición
    worker_connections  1024;
}

http {
    include       mime.types;
    default_type  application/octet-stream;

    log_format  main  '$remote_addr - $remote_user [$time_local] $request '
                      '"$status" $body_bytes_sent "$http_referer" '
                      '"$http_user_agent" "$http_x_forwarded_for"';

    access_log  logs/access.log  main;
    sendfile        on;
    keepalive_timeout  65;
    # Comprimir todo, útil para ahorrar ancho de banda.
    gzip  on;

    server {
        listen       80;
        server_name  www.servidor,com;
        access_log  logs/host.access.log  main;
        location / {
            # Por defecto pasar todas las peticiones al Apache.
            proxy_pass http://127.0.0.1:8080/;
            proxy_redirect off;
            proxy_set_header Host $host;
            proxy_set_header X-Real-IP $remote_addr;

            client_max_body_size 10m;
            client_body_buffer_size 128k;
            proxy_connect_timeout 90;
            proxy_send_timeout 90;
            proxy_read_timeout 90;
            proxy_buffer_size       4k;
            proxy_buffers       4   32k;
            proxy_busy_buffers_size 64k;
            proxy_temp_file_write_size   64k;
        }
        # Si lo requerido es una archivo "estático", nginx tiene que responder,
        # y el cliente no tiene que volver a preguntar (gracias al cache).
        location ~* ^.+.(jpg|jpeg|gif|png|ico|css|zip|tgz|gz|rar|bz2|doc|xls|exe|pdf|ppt|txt|tar|mid|midi|wav|bmp|rtf|js)$ {
             root   /var/www/html/;
             expires max;
        }
        # Página estática de error
        error_page  404              /404.html;

        # redirect server error pages to the static page /50x.html
        #
        error_page   500 502 503 504  /50x.html;
        location = /50x.html {
            root   html;
        }
    }

}

Para este ejemplo el Apache tiene que escuchar el puerto 8080 del IP 127.0.0.1. También sería razonable desabilitar los logs de acceso (pero los de error no, ya que PHP escribiría ahí los errores) ya que esos logs son generados por nginx, y para qué repetir datos?

Lo aquí expresado es estrictamente personal y nada tiene que ver con el CNC o el NIC, aunque yo trabaje en el CNC.

En estos días se hizo eco el “hackeo” a la página del NIC, un buen hackeo realizado por un conocido bastante inteligente (nada contra él, todo bien) que aprovechaba algunos bugs del CGI escrito en Perl (hace más de 10 años) haciendo un inyección (no voy a entrar en detalles). Los “daños” realizado fueron mínimos ya que solo entraron al servidor web que no tiene nada de información, bases de datos ni nada relacionado al NIC o al CNC, si desearían hackear necesitarían hacer algo mejor que eso ya que todo está en una red privada.

Si piensan que los culpables somos los funcionarios actuales del CNC, la respuesta es NO, ya que esa página está desde hace mas de 10 años, y tenemos una larga lista de actividades de cosas a hacer, no podemos pasar la vida controlando cosas que fueron hechas hace años y que funcionan (o así parece).

Hasta ahí todo bien, ahora lo que me molesta y bastante es que algunas personas anden opinando por foros o algo así, y mucho más un tal Lucho Benítez (ex funcionario del CNC, de la misma época cuando el CGI fue escrito) esté escribiendo artículos amarillistas y aprovechándose de la ignorancia de los medios de prensa, para hacer polémicas (flameware) y así tener unas cuantas visitas en su blog (y hacer unos cuantos dolares), típico troll, alguien debería comentarle que si quiere visitantes existe digg, o meneame si solo habla español.

Investigué algo referente a Lucho Benítez, lastimosamente google no me dijo nada, pregunté a gente del CNC, y tampoco me dijeron nada, por lo visto su paso por el CNC no marcó historia como el de algunos legendarios que sus nombres aún se escuchan por los pasillos. A continuación responderé algunas cosas de su artículo amarillista.

Que sucedió en el CNC? ya no tienen presupuesto para el mantenimiento de los servicios? Habría que recordar que este también es un MONOPOLIO al que ni la prensa ni los proveedores hacen referencia.

Monopolio?!, que otra empresa está preparada para tener el servicio de NIC?, algún grupito de “hackers” o usuarios Unix?, otro ente público? alguna empresa privada?. Si tienen problemas deberían hablar con el Rectorado UNA, no con el CNC.

Por qué este evento desnuda un problema grave? Simplemente por que el DNS forma parte de los protocolos que hacen a la arquitectura de Internet. Sin el DNS del NIC.py nadie en ninguna parte del mundo podrá llegar a servidores que tienen su dominio bajo .py. Podrían hacerlo por el número IP, pero no por el nombre de dominio. Al tomar cierto control de este equipo es solo cuestión de tiempo, (y si se tiene el conocimiento adecuado) tomar el control del resto de la infraestructura.

Linda clase para muggles pero totalmente irrelevante, y nada tiene que ver con el servidor web que fue “hackeado”.

Es por ello que me parece gravisima la desidia y/o negligencia del personal del CNC, y ante todo una vez más la población (sobre todo los usuarios) de vuelta esta desprotegida, y seguirá así, si no cambian ciertas prácticas.

Que tiene que ver eso con un servidor web?

Otra cosa que me molesta es la gente ignorante que se quejan por los precios del NIC asociando al CNC como responsable, si tienen problemas con el precio (o burocracia) deberían hablar con la gente del Rectorado (somos dependiente del Rectorado UNA) o comprarse .com

Modestia aparte, en el CNC sólo trabaja gente muy buena (entre las mejores del Paraguay, si no me creen pueden googlear el nombre de algún funcionario del área técnica), pero el problema principal es la constante rotación del personal debido al bajo salario (somos funcionarios del Rectorado).

Probably you may be wondering why another file share system?, the answer is quite simple, I got tired of wait more than a  minute because I was not a premium user, or download slower over the time when download a bunch of things.

Another things that really really bother me is that if my connection goes down during a large download, I need to start again, and also, I cannot have parallel download.

So, I created FileS3, a simple share system, where every user is a premium user.

What is next:

• Right now the Link live time is two hours, What I will do next is calculate the LLT (link live time) based on the file size.
• MP3-embedding, if you upload an mp3 file, FileS3 will generate the HTML code for embedded an mp3 player in your blog.
• Internationalization, because not all the people speak only English…
• Desktop uploader: This will be a cool Python+Gtk2 (Of course will be Free Software) app that will help user to upload largest file and pause.

Archivos estáticos (*.png, *.jpg, *.js, *.css, etc)

Aunque Apache es un gran servidor web, perfecto para todas las consultas dinámicas (mod_php, mod_*), consultas CGI, pero es demasiado costosa para procesar archivos estáticos, con esto no estoy diciendo que tener archivo estáticos con Apache este mal, solamente digo que si quieren ahorrar recursos para recibir mas visitantes se debe cambiar esto.

Para eso existen varios servidores “lightweight”, yo recomendaría NGinx (se lee engine x) pero hay varias alterativas, solo basta googlear un poco (también leí mucho sobre el http://www.lighttpd.net/).

Si se pregunta porque estos servidores “lightweight” son mejores que Apache para archivos estáticos, la respuesta es que estos servidores usan hilos (o métodos similares) para atender a varias consultas en simultaneo, ademas cuenta con una arquitectura mucho mas simple y pequeña, lo que se adecua a las necesitas de los archivos estáticos, ya que no necesitan nada mas que ser leídas del disco duro y ser enviada al cliente.

Otra cosa muy importante para ahorrar ancho de banda, es el cacheo en el cliente. Este cacheo es simplemente que el servidor le dice al browser (claro, a firefox casi siempre) que estos archivos estáticos no cambiaran en un tiempo dado (10 días, 20 días, 10 meses, etc), entonces el browser una vez que obtiene los archivos no vuelve a bajar el mismo archivo ya que sabe que ese archivo no va a cambiar, y tiene una copia del archivo en el disco. Para realizar esta configuracion con el NGinx pueden leer esta pagina, si usan otro servidor deben buscar como manipular el header “Expires”.

Seguramente se estarán preguntando, que pasaría si actualizamos algún archivo estático, bueno, el browser no se enteraría mientras que no se alcance el tiempo de validez del cache. Pero no se alarmen, existe una solución bastante simple, un poco de orden todo lo arregla.

Ya que nuestro contenido dinámico no se debe cachear (o se debe cachear por un tiempo mínimo como 10 min, 1h ,etc), y ya que el contenido dinámico incluye, es la que incluye a el contenido estático, nuestro problema esta resuelto!, simplemente tendremos que crear un sistema rudimentario de versionamiento. Ejemplo:

Esta es la manera como una pagina incluye a un elemento estático, un archivo css:
<link rel='stylesheet' href='/style.css' type='text/css' />

Con el versionamiento seria algo asi:
<link rel='stylesheet' href='/css/1/style.css' type='text/css' />

Entonces cuando cambiamos algo, simplemente tendremos que crear una
nueva carpeta y actualizar las referencias de la pagina hacia el elemento
estatico (si es una web en serio organizada no seria un problema).
<link rel='stylesheet' href='/css/2/style.css' type='text/css' />

Como ven, no es una solución complicada y así no tenemos excusas para utilizar el cacheo de archivos y así empezar a ahorrar un montón de ancho de banda.

Otro tip importante, para ahorrar ancho de banda es utilizar algún módulo del servidor que pueda comprimir los archivos antes de enviar (si el browser soporta). Aquí está un ejemplo de configuración para el NGinx que tiene activado la compression (gzip).

Consultas dinámicas. (*.php, cualquier otro)

Bases de datos…

En esta sección hay mucho para hablar, yo me voy a enfocar en lo mas conozco, y en lo que pienso es en donde mayor desoptimización hay, las bases de datos.

La base de datos es un mal necesario, digo mal, porque es bastante costosa, pero no podemos vivir sin ella, es costosa porque hay autenticación (casi siempre, excepto SQLite), comunicación por la red (casi todos), compilación del código SQL, ejecución del código y acceder al disco duro. Pero como dije antes, no podemos vivir sin el, entonces la solución es evitarlo cuando sea posible, para eso podemos cachear el resultado de una consulta con un TTL (time to live) apropiado. El medio de almacenamiento puede ser un archivo en el disco duro, aunque es costoso el acceso al disco duro hoy en día los sistemas operativos tienen en memoria RAM los archivos que son leídos frecuentemente. Cuando hay varios servidores webs, la mejor alternativa seria guardar el cache en un servidor de Memcached, así no se duplica el cache.

Para ayudar a todo que es cacheo, en mi opinión, se debería construir un Capa de abstracción entre el acceso a base de datos y la aplicación (similiar al PDO del PHP5) y ahí implementar todo lo que sea cache. Ahora mismo estoy escribiendo un lenguaje de modelado de datos y su generador de código. Su misión sera que genera las tablas y el código PHP (mas adelante python, java,etc) para acceder a la tablas sin escribir SQL (similar a www.metastorage.net) y ahí estará implementado cacheo de consultas a disco duro, memcached o cualquier otro medio. Más adelante estaré hablando mas sobre este proyecto, que espero que muy pronto este todo terminado.

Minimizando el tráfico.

Al igual que los archivos estáticos, los archivos dinámicos pueden ser cacheado y comprimidos. Claro que el TTL tiene que ser un tiempo razonable. Imagínense la página principal de un diario digital, esa página si tiene último momento, no cambiaría tan frecuentemente, cambiaría a cada 5 minutos o 10 minutos, entonces para que generar toda la página para cada visitante?. La solución sería (para los usuarios que no este logueados, si soporta logueo) cachear toda la página (en el disco duro) y comprimir así tenemos dos versiones del mismo cache, la comprimida y la descomprimida, porque comprimir “on the fly” es costosa, se pierde tiempo y valiosos ciclos de CPU. Para cada visitante enviamos el cache comprimido si soporta o el cache normal y también le enviamos el tiempo que falta para que el cache sea recreado (para un diario yo pondria 5 ~ 10 min). Y para los artículos que generalmente no cambian creo que un TTL adecuado es de 2 horas o algo así.

Hace algún tiempo escribí una clase que hace eso mismo, gCache.

APC.

APC (Alternative PHP Cache) es un excelente cache en RAM del bytecode del PHP (PHP no es interpretado desde la versión 4). Para demostrar la diferencia, hice una simple prueba con la pagina principal del  FileS3, cuya pagina esta bien optimizada ya que cuenta con un cache y en el momento de la prueba el cache existia, lo que significa que solo una par de lineas de códigos PHP fueron ejecutadas, ademas fue probada en el servidor para que no haya retardo de red.

Para la prueba utilice ApacheBench (ab -c 30 -t 30 http://local.files3.com/) simulando a 30 usuarios concurrentes que visitaban a http://local.files3.com/ por 30 seguntos.

This is ApacheBench, Version 2.0.40-dev <$Revision: 1.146 $> apache-2.0
Copyright 1996 Adam Twiss, Zeus Technology Ltd, http://www.zeustech.net/
Copyright 2006 The Apache Software Foundation, http://www.apache.org/

Benchmarking local.files3.com (be patient)

Server Software:        Apache/2.2.8
Server Hostname:        local.files3.com
Server Port:            80

Document Path:          /
Document Length:        7232 bytes

Concurrency Level:      30
Time taken for tests:   30.8135 seconds
Complete requests:      3166
Failed requests:        0
Write errors:           0
Total transferred:      23656585 bytes
HTML transferred:       22918208 bytes
Requests per second:    105.50 [#/sec] (mean)
Time per request:       284.347 [ms] (mean)
Time per request:       9.478 [ms] (mean, across all concurrent requests)
Transfer rate:          769.86 [Kbytes/sec] received

Connection Times (ms)
              min  mean[+/-sd] median   max
Connect:        0    0  10.1      0     117
Processing:    19  281  75.0    282     675
Waiting:        1  248  75.2    252     653
Total:         20  282  74.0    283     675

Percentage of the requests served within a certain time (ms)
  50%    283
  66%    302
  75%    316
  80%    328
  90%    364
  95%    408
  98%    472
  99%    499
 100%    675 (longest request)

Como verán, con toda la optimización pudimos responder 3166 paginas. Ahora instale APC ( yum install php-pecl-apc.i386  -y), y la configuración  de facto, realice la misma prueba y aquí están los resultados.

This is ApacheBench, Version 2.0.40-dev <$Revision: 1.146 $> apache-2.0
Copyright 1996 Adam Twiss, Zeus Technology Ltd, http://www.zeustech.net/
Copyright 2006 The Apache Software Foundation, http://www.apache.org/

Benchmarking local.files3.com (be patient)

Server Software:        Apache/2.2.8
Server Hostname:        local.files3.com
Server Port:            80

Document Path:          /
Document Length:        7244 bytes

Concurrency Level:      30
Time taken for tests:   30.1087 seconds
Complete requests:      7028
Failed requests:        0
Write errors:           0
Total transferred:      52570787 bytes
HTML transferred:       50932564 bytes
Requests per second:    234.26 [#/sec] (mean)
Time per request:       128.064 [ms] (mean)
Time per request:       4.269 [ms] (mean, across all concurrent requests)
Transfer rate:          1711.20 [Kbytes/sec] received

Connection Times (ms)
              min  mean[+/-sd] median   max
Connect:        0    0   4.2      0      69
Processing:    39  126  23.1    123     300
Waiting:        1  123  22.7    120     300
Total:         39  127  22.9    123     300

Percentage of the requests served within a certain time (ms)
  50%    123
  66%    130
  75%    136
  80%    141
  90%    154
  95%    169
  98%    191
  99%    206
 100%    300 (longest request)

El resultado es asombroso, ahora pudimos servir 7028 paginas, con solamente haber instalado APC, si pasan un poco mas de tiempo tuneando, podríamos mejor mucho mas.

Tu experiencia!

Seria espectacular si ustedes comparten aqui sus metodos de optimizacion para ayudarnos entre todos, varias cabezas son mejores que una.

Saludos.

Basicamente en este post voy a describir, paso por paso lo que hice para tener hermosas presentaciones en pdf (código fuente), escribiendo un poco de codigo con LaTeX. Antes que nada utilize la guia escrita por Matt Welsh (Creating Presentations in PDFLaTeX), por cierto muy buena guia, excepto que no pude instarlas las fuentes con el script perl que esta en esa pagina.

• Deben bajarse el textslides.tbz2.
• Descomprimir ( tar xfvj textslides.tbz2 -C $HOME)
• Editar el archivo de configuración de cuenta
  • echo “export TEXINPUTS=\$TEXINPUTS:~/.texslides/” >> ~/.bashrc
  • echo “export PATH=\$PATH:~/.texslides/” >> ~/.bashrc
• Para instalar fuentes nuevas, hacer lo siguiente:
  • Copiar las fuentes en una carpeta dada (archivos *.ttf)
  • Luego ejecutar “addfont”
  • Si siguieron todos los pasos las fuentes estaran bien instaladas.
• Luego para compilar el archivos Latex deben realizar lo siguiente:
  • pdflatex archivo.tex
  • ppower4 archivo.pdf carchivo.pdf
  • mv carchivo.pdf archivo.pdf

Básicamente crear presentaciones con LaTeX, es algo sencillo, y vale la pena si la presentación es simple, como imágenes de fondos, incluir imágenes, citar cosas. La cosa se va complicando (cosa que me pasó) cuando se requiere hacer cosas complejas, como resaltar código (escribí un pequeño script en python que con otro script bash hace eso, es algo grocero, pero funciona más o menos). Aún asi para presentaciones normales, lo mejor es utilizar LaTeX (claro con ViM), porque todo está en su lugar, no hay utilizar el mouse para alinear textos, ni nada.

Como me encanto el LaTeX (la idea de no depender del Impress me encanta), decidí comenzar un proyecto llamado GeekSlide, que básicamente será un generador de presentaciones (por ahora a HTML) basado en modelado de texto bastante sencillo (similar pero no igual al RST), que será modular, el “core” no generará ninguna presentación, solo parseará el texto y pasara esa información a un “render” (un plug-in) que será el encargado de generar la presentación.

Así será un típico archivo de gslides (ojo: no es gnu/slides, es GeekSlides).

% Esto es un comentario que será ignorado por el parseador
% Definir variables globales
% Estas variables serán pasadas al render, generalmente será
% útil para generar la primera página
title: Introducción a GeekSlides.
author: Cesar Rodas
email: talks@cesar.la
% “—” Es el separador de páginas.
—
=Que es GeekSlides= % Típico Título (header 1)
% Llamamos a la función “gradient” definida en el “render”.
% Básicamente mostrará los items en un color claro, luego
% cambiarán de color en los siguientes slides.
{gradient}
* Generador de Presentaciones.
* Totalmente modular.
* Open source.
—
=Caracteristicas=
==Textos==
{font,¨arial”,”14px”}
* *Texto en negríta*
* _Texto en cursiva_
* Resalto de código.
{source,”foobar.php”,”grey”}
–
{center}
=¿Preguntas?=

Como se darán cuenta la sintaxis es mucho más amigable que el LaTeX, y es bastante útil (a no ser que necesiten realizar complejas formulas matemáticas). El proyecto ahora mismo es solo un prototipo que estoy armando, y creo que pronto estará disponible para que lo puedan utilizar, extender, o lo que quiera. El proyecto será publicado en PHPClasses, y la documentación estará aqui mismo.

As in previous versions, PHPAJAX aims to help developer to write AJAX app. without write javascript (or writing just a little of). In previous versions execute PHP functions directly from the browser (as most of AJAX libraries), with some little advantages, such as read data directly from the HTML objects, File upload, and others.

The new version of PHPAJAX will be completely rewritten from scratch, and it will not use anymore Prototype, it will have its own set of javascript code, optimized to what the PHPAJAX program does. The idea is produce the Javascript code on the fly (then in a near future js-cache the code). The code by default will be obfuscated and minimized.

Basically the PHPAJAX compatibility will be broken right now, later I’ll code a wrapper that will execute PHPAJAX 2 code.

Some features of the PHPAJAX 3 will be:

• File Upload.
• Better PHP-DOM functions, to manipulate HTML objects as if they were PHP objects.
• Special Objects.
  • Drag and Drop (containers and objects)
  • Autocomplete fields.
• PHP to JS API for write Javascript code using just PHP.
• Easy to extends.

I have not an official release date, but I’m doing my best, I think it will be available in two weeks, you can keep an eye on my blog, I promise that I will disclose the repository URL soon.

BTW, you can take a look on Fossil SCM, because I’m using it for this project.

Happy hacking, have a nice weekend!

The greatest part was that I met the administrator of the l.root-servers.net (If you don’t know what is the root-servers.net read this) and he gave us useful tricks of how to manage a huge network (just figure out the hard work of a root server).

Also I met people from other NICs, it was a great experiences.

From now on, I’ll start to write in English and Spanish (depending of my mood) about these topics, and also I’ll write some scripts to manage the DNSSEC, also I’ll write about the DNS poisoning and other attacks (just to show how weak is the DNS), so if you’re interested just keep watching my site.

I’d try to talk about *similar* things (not just translations) in both languages, and of course, I’ll try to improve my English (now I’m studying).

So welcome back to my playground!

En la semana tuve una nueva meta, tener un nuevo mail @apache.org, @php.net, ambos antes de tener 23 años, aprovechando que me quedan 2 años y dos dias ;).

Bueno, me puse manos a la obra, comenzé por el que creía que sería más difícil, por apache (sin desprestigiar a @php.net), y la verdad que no me fué tan bien, pero claro que eso no me va a desanimar. Luego le llego al turno a php, y para eso la manera más fácil para mí y donde me sentiría mas cómodo, fue hacer una contribución en PEAR, y la verdad que mi primer “contacto” con PEAR el año pasado no me fue tan bien, pero por suerte este año me fue mejor de lo que estaba esperando.

Como habrán leído, estoy trabajando en mis tiempos libres en mi proyecto PEAR, una implementación del PageRank en PHP, que podrá ser ejecutada como un solo proceso, o en paralelo en varias máquinas.

El diseño de la clase, es bastante modular, y la persona que desea usarla debería tener una lista de números (fuente->destino), que se puede tener con un crawler, o bien puede ser útil para alguna red social para saber quienes son los “mejores” (más famosos, más activos, etc). usuarios.

Para mis pruebas, hice un pequeño y genérico crawler en PHP (que pronto estará publicado en PHPClasses), e indexé 116.396 páginas, 7.132.973 links, y 23.598.922 “nodos de links” (los intercambios de links origen->destino).

Como sabrán, el PageRank, es un proceso recursivo, que se necesitan iteraciones, osea repetir el proceso del calculado N veces (en el paper dice que ~52 veces fueron suficientes para sus pruebas), también menciona que es un proceso lento.

En mis pruebas, use a MySQL, como repositorio de mis datos, y para mi sorpresa la iteración tardó 2 horas exactamente, lo que significa que tardaría 104 horas (4 días) para calcular el PR de todo mi ejemplo, lo que es un tiempo inaceptable para tan insignificante grupo de páginas. Entonces buscando una solución, me acorde de mis magistrales clases de Sistemas Operativos con el Prof. Carlos Zayas, el capítulo de sistemas de archivos, específicamente la parte de cacheo en memoria, y empecé a desarrollar una capa de cacheo entre el PHP y el origen de los datos (en mi caso MySQL), el primer algoritmo fue el MRU. Alguna vez implementé este algoritmo en C, lo cual fue sencillo gracias a los punteros, pero en PHP me fue complicado, ya que no hay punteros sólo referencias, lo cual es un concepto nuevo para mí (humanware-error), y la solución era peor que la cura. Luego me di cuenta que los datos eran secuenciales, y que pensé que un cacheo usando FIFO sería suficiente, y empecé a codificar.

Para mi sorpresa, el FIFO con un buen tamaño (100MB), es perfecto, de 2 horas por iteración pasó a ser 16 minutos por iteración. Y viendo en los logs, me dí cuenta que el cache respondió a 14.598.272 consultas. Gracias a Prof. Carlos Zayas, mis problemas fueron resueltos.

Espero terminar pronto con este proyecto, por si alguien quiera ver el código, lo puede hacer en mi lugar de juego.

El ataque de diccionario, es el ataque más tonto que un pseudo-spammer puede hacer, y ya que es un ataque tonto, tiene una solución bastante sencilla. El ataque consiste en lo siguiente.

• Toman un e-mail real (Ejemplo: crodas@foo-bar.com)
• Luego se le agregan letras randomicas al inicio al final

La solución se simple, hay que seleccionar todos lo mails que fueron enviados a destinatarios no existentes, luego agrupar por IP, y comparar a ver si los destinatarios son similares, si son es un ataque de diccionario. Este script funciona con el output del Log del sendmail.

#!/usr/bin/php -q
<?php
# Dedicado para los que piensan que PHP es solo para páginas webs
# y para las personas tontas que comparan un framework cualquiera
# con un lenguaje de programación.
#
if ( isset($argv[1]) && $argv[1] == "--debug")
    define("DEBUG",1);

function x_readline()
{
    return trim(fgets(STDIN));
}

function asum($x,$y)
{
    $x += $y;
    return $x;
}

$ip=array();
$dst=array();
while ($line=x_readline())
{
    $line = strtolower($line);

    preg_match("/\]\: ([a-zA-Z0-9]+):.*from\=.*relay=.*\[([0-9\.]+)\]/i",$line,$result);
    if ( count($result) > 0) $ip[$result[1]] = $result[2];
    if ( strpos($line,"user unknown") !== false )
    {
        preg_match("/]\: ([a-zA-Z0-9]+):.*to=<?([^\@]+)>?/i",$line,$result);
        if ( count($result) > 0 && isset($ip[$result[1]]) )
            $dst[ $ip[$result[1]] ][] = $result[2];
    }
}
$result=array();
#ahora a buscar los posibles candidatos
foreach($dst as $ip => $mail)
{
    $tmp=array();
    $t = count($mail);
    if ( $t < 5) continue; /* una regla mia, un mínimo de 5 mails fallidos para el control */
    for($i=0; $i < $t-1; $i++)
    {
        $threshold = (strlen($mail[$i]) + strlen($mail[$i]))/2 * 0.3;
        $weight = levenshtein($mail[$i],$mail[$i+1]);
        $tmp[] = $weight < $threshold && $weight!=0  ? 1 : -1;
    }
    $result[$ip] = array_reduce($tmp,"asum");
}

foreach($result as $ip => $weight)
{
    if ( $weight < 0) continue;
    print "$ip\n";
    if (defined("DEBUG")) print_r($dst[$ip]);
}
?>

El script devuelve una lista de IPs que realizan ataques de SPAM. Esta lista es suficiente para poder combatirlo, ejemplo ejecutar periodicamente (crontab) a cada 3 (es un ejemplo) horas y agregar en la lista de bloqueos del sendmail. Aquí un script bash que hace el trabajo “duro” de darle forma a el “output” del php.

#!/bin/bash
#configuracion
LOG=/var/log/maillog
SENDMAIL=/etc/mail/
DB=/etc/mail/access
DATE=`date`
TEXT="550 We don't accept mail from spammers # Auto added $DATE"
#el programa en sí
if [ `whoami` != "root" ]
then
    echo "Only root can run this script"
    exit
fi

find_in_access() {
    VALUE=$1
    local ACCESSIP
    for ACCESSIP in $( cat $DB | awk '{print $1}' );
    do
        if [  "$ACCESSIP" = "$VALUE" ];
        then
            return 0
        fi
    done
    return 1
}

for SPAMMER in `cat $LOG | php php_dict_attack.php`
do
    find_in_access $IP
    if [ $? -eq 1 ];
    then
        echo "$SPAMMER			$TEXT" >> $DB
    fi
done
cd $SENDMAIL
make

Primero es lo primero, tuve que “instalar” el driver de sonido, y digo “instalar” porque solo faltaba levantar el módulo en el kernel, como lo describe el glorioso handbook del diablito, pero no había nada emocionante ahi… aparte que ganas me sobraban de recompilar el kernel, y eso fue lo que hice (para este paso necesitan haber instalado los fuentes)

cd /usr/src/sys/$ARCH/conf; #en mi caso $ARCH=i386
cat GENERIC  |  sed "s/GENERIC/CRODAS/g" > CRODAS # "CRODAS" va a ser el kernel (soy un narcisista :P)
echo device sound >> CRODAS
echo device snd_emu10k1 >> CRODAS
echo device snd_sbc >> CRODAS
echo device snd_sb16 >> CRODAS
cd /usr/src
make buildkernel KERNCONF=CRODAS # compilar el kernel
make installkernel KERNCONF=CRODAS # instalando el kernel
reboot # algunas (solo raras) veces hay que reiniciar un verdadero sistema operativo

Luego de esperar no mas de media hora (depende del hardware) ya podía escuchar música con XMMS (/usr/ports/multimedia/xmms), pero todavía no era suficiente para ver el vídeo “cultural”, entonces me puse a googlear y encontre los alternativas:

• Instalar el Firefox de Linux, luego instalar los drivers como si fuera en cualquier distro (no es un reto)

• Instalar el plugin flash con un “wrapper” para Freebsd (como Stallman diría “the lesser evil”)

Para ello hice los siquiente:

cd /usr/ports/www/nspluginwrapper && make install clean
cd /usr/ports/www/linux-flashplugin7 && make install clean
nspluginwrapper -v -a -i # como el usuario que va a ejecutar firefox

Y al fin ya pude ver el video educativo…

Como verán la versión del flash es 7, y existe algunos sitios (gracias a Dios Youtube no) que su “player” necesita flash 9, para esos casos una buena mirada hacia sus fuentes y “wget” lo pueden solucionar.

Larga vida a UNIX

Antes que nada tuve que cambiar el tamaño de una partición (dejar libre unos 12GB) para poder instalar FreeBSD 7, en mi notebook. La instalación no fue nada fuera de lo normal, excepto que el FreeBSD no modifico mi MBR, ya que es más fácil (para mí) modificar el grub.

La mejor característica que tiene FreeBSD es el mágico directorio “/usr/src” donde se encuentra los fuentes de todos los fuentes, lo que se hace bastante fácil recompilar la “base” de FreeBSD. Los demás programas se encuentran en “/usr/ports”.

Otra cosa que me gusta mucho, es que viene con menos abstracción, (casi) no existen utilitarios para configurar cosas, solo archivos *.conf.

La instalación fue con X11 y por supuesto con Gnome, ya que no soy partidario de escritorios que mal gastan recursos (ya que tan escritos con “extensiones” de grandes lenguajes). Para que el FreeBSD inicie en modo gráfico, hay que modificar el archivo /etc/ttys que es similar al /etc/inittab de GNU/Linux, pero más simple y más poderoso, ya que se puede configurar fácilmente para ejecute un programa en tty, en mi caso el gdm de gnome. El archivo quedo similar al siguiente:

ttyv0 “/usr/libexec/getty Pc” cons25 on secure
# Virtual terminals
ttyv1 “/usr/libexec/getty Pc” cons25 on secure
ttyv2 “/usr/libexec/getty Pc” cons25 on secure
ttyv3 “/usr/libexec/getty Pc” cons25 on secure
ttyv4 “/usr/libexec/getty Pc” cons25 on secure
ttyv5 “/usr/libexec/getty Pc” cons25 on secure
ttyv6 “/usr/libexec/getty Pc” cons25 on secure
ttyv7 “/usr/local/sbin/gdm” gdm on secure

Los ports que instalé en mi máquina son:

• /usr/ports/devel/kdevelop = El mejor IDE que conocí del mundo para mí.
• /usr/ports/security/openssh = El servidor OpenSSH
• /usr/ports/net-im/pidgin = Todos necesitamos comunicarnos
• /usr/ports/multimedia/vlc = Lo mejor para ver vídeos
• /usr/ports/multimedia/xmms = Músicas, músicas

Para esas carpetas hice lo siguiente:

cd $DIR; make install clean

Larga vida a UNIX!

#!/usr/bin/php
<?php
# Dedicado para los que piensan que PHP es solo para páginas webs
# y para las personas tontas que comparan un framework cualquiera
# con un lenguaje de programación.
#

/**/
function x_readline()
{
    return trim(fgets(STDIN));
}

function get_better_search_engine($Query,$Server,&$steps_done)
{
    $result=array();
    $max = 0;
    $max_pos = 0;
    for($e=0; $e < count($Server); $e++)
    {
        $perfect = true;

        for ($i=$steps_done; $i < count($Query); $i++)
        {
            if ( $Query[$i] == $Server[$e])
            {
                $perfect=false;
                if ( $max < $i)
                {
                    $max = $i;
                    $max_pos = $e;
                }
                break;
            }
        }
        if ( $perfect === true)
            return true; #perfect search engine
    }
    $steps_done = $max;
    return false; # we got a good search, but it cannot handle all queries
}

function get_lowest_switch($Query,$Server)
{
    $pos = 0;
    $switch=0;
    $i=0;
    while( get_better_search_engine($Query,$Server,$i) === false )
    {
        $switch++;

    }
    return $switch;
}

define('NO_WHERE',0);   # todavia no comenzamos
define('IN_INPUT_PHASE_1',1);  # inicializacion de servidores
define('IN_INPUT_PHASE_2',2);  # leyendo servidores
define('IN_INPUT_PHASE_3',3);  # inicializacion de consultas
define('IN_INPUT_PHASE_4',4);  # leyendo consultas
$status = NO_WHERE;
$total=0; # numero total a "inputs" a procesar
$cnt=0;
while ( ($line = x_readline()) != "")
{
    switch($status)
    {
        case NO_WHERE: # primera linea
            $total = (int) $line;
            $status++;
            break;
        case IN_INPUT_PHASE_1:
            $cnt++;
            $nServer= (int) $line;
            $Server = array();
            $status++;
            break;
        case IN_INPUT_PHASE_2:
            $Server[] = $line;
            if ( count($Server)==$nServer)
                $status++;
            break;
        case IN_INPUT_PHASE_3:
            $nQuery= (int) $line;
            if($nQuery==0) # no hay consultas, no hay switch
            {
                echo "Case #$cnt: 0\n";
                $status=IN_INPUT_PHASE_1;
                break;
            }
            $Query = array();
            $status++;
            break;
        case IN_INPUT_PHASE_4:
            $Query[] = $line;
            if ( count($Query)==$nQuery)
            {
                echo "Case #$cnt: ".get_lowest_switch($Query,$Server)."\n";
                $status=IN_INPUT_PHASE_1;
            }
            break;
    }
}
?>

El enunciado del problema:

Problem

The urban legend goes that if you go to the Google homepage and search for “Google”, the universe will implode. We have a secret to share… It is true! Please don’t try it, or tell anyone. All right, maybe not. We are just kidding.

The same is not true for a universe far far away. In that universe, if you search on any search engine for that search engine’s name, the universe does implode!

To combat this, people came up with an interesting solution. All queries are pooled together. They are passed to a central system that decides which query goes to which search engine. The central system sends a series of queries to one search engine, and can switch to another at any time. Queries must be processed in the order they’re received. The central system must never send a query to a search engine whose name matches the query. In order to reduce costs, the number of switches should be minimized.

Your task is to tell us how many times the central system will have to switch between search engines, assuming that we program it optimally.

Input

The first line of the input file contains the number of cases, N. N test cases follow.

Each case starts with the number S — the number of search engines. The next S lines each contain the name of a search engine. Each search engine name is no more than one hundred characters long and contains only uppercase letters, lowercase letters, spaces, and numbers. There will not be two search engines with the same name.

The following line contains a number Q — the number of incoming queries. The next Q lines will each contain a query. Each query will be the name of a search engine in the case.

Output

For each input case, you should output:

Case #X: Y

where X is the number of the test case and Y is the number of search engine switches. Do not count the initial choice of a search engine as a switch.

Limits

0 < N ≤ 20

Small dataset

2 ≤ S ≤ 10

0 ≤ Q ≤ 100

Large dataset

2 ≤ S ≤ 100

0 ≤ Q ≤ 1000

In the first case, one possible solution is to start by using Dont Ask, and switch to NSM after query number 8.
For the second case, you can use B9, and not need to make any switches.

#!/usr/bin/php
<?php
# Dedicado para los que piensan que PHP es solo para pàginas webs
# y para las personas tontas que comparan un framework cualquiera
# con un lenguaje de programación
#

/**/
function x_readline()
{
    return trim(fgets(STDIN));
}

function hour2minutes($hour)
{
    $tmp = explode(":",$hour);
    return $tmp[0] * 60  + $tmp[1];
}

function get_number_train($depart, $arrival, $ttime)
{
    $ret=$tmp=0;
    sort($depart);
    sort($arrival);
    if ( count($arrival)==0)
        $ret = count($depart);
    else
    {
        foreach($depart as $pzTrain)
        {
            if ( $tmp < count($arrival) && $pzTrain >= ($arrival[$tmp] + $ttime))
                $tmp++;
            else
                $ret++;
        }
    }
    return $ret;
}

$total=0; # numero total a "inputs" a procesar

define('NO_WHERE',0);   # todavia no comenzamos
define('IN_INPUT_PHASE_1',1);  # ttime
define('IN_INPUT_PHASE_2',2);  # cantidad de "viajes"
define('IN_READ_TIME',3);

$status = NO_WHERE;
$inp=0;
while ( ($line = x_readline()) != "")
{
    #print "+".$line." ($status)\n";
    switch($status)
    {
        case NO_WHERE: # primera linea
            $total = (int) $line;
            $status++;
            break;
        case IN_INPUT_PHASE_1:
            #limpieza del estado anterior
            $inp++;
            #print "Input $inp\n";
            $input_line=$ttime=$cnt=$pzTrainA=$pzTrainB=0;
            $trips=$inA=$outA=$inB=$outB=array();
            #
            $ttime = (int) $line;
            $status++;
            break;
        case IN_INPUT_PHASE_2:
            $trips=explode(" ",$line);
            $input_line = $trips[0] + $trips[1];
            $status++;
            break;
        case IN_READ_TIME:
            $time = array_map("hour2minutes",explode(" ",$line));
            if ( $cnt < $trips[0]) {
                $outA[]  = $time[0];
                $inB[]   = $time[1];
            } else {
                $outB[]  = $time[0];
                $inA[]   = $time[1];
            }
            if ( ++$cnt == $input_line)  {
                $pzTrainA = get_number_train($outA,$inA,$ttime);
                $pzTrainB = get_number_train($outB,$inB,$ttime);
                print "Case #".($inp).": $pzTrainA $pzTrainB\n";
                $status = IN_INPUT_PHASE_1;
            }
            break;
    }
}
?>

Nada mas y nada menos un problema de CodeJam resuelto en PHP… no miré si PHP se puede usar, de cualquier manera estoy realizado… demostrando que no solo la viborita (o la mala extension de una gran Lenguaje) pueden hacer cosas así…

Para los que no tiene acceso al CodeJam, aqui escribo el enunciado del problema:

Problem

A train line has two stations on it, A and B. Trains can take trips from A to B or from B to A multiple times during a day. When a train arrives at B from A (or arrives at A from B), it needs a certain amount of time before it is ready to take the return journey - this is the turnaround time. For example, if a train arrives at 12:00 and the turnaround time is 0 minutes, it can leave immediately, at 12:00.

A train timetable specifies departure and arrival time of all trips between A and B. The train company needs to know how many trains have to start the day at A and B in order to make the timetable work: whenever a train is supposed to leave A or B, there must actually be one there ready to go. There are passing sections on the track, so trains don’t necessarily arrive in the same order that they leave. Trains may not travel on trips that do not appear on the schedule.

Input

The first line of input gives the number of cases, N. N test cases follow.Each case contains a number of lines. The first line is the turnaround time, T, in minutes. The next line has two numbers on it, NA and NB. NA is the number of trips from A to B, and NB is the number of trips from B to A. Then there are NA lines giving the details of the trips from A to B.

Each line contains two fields, giving the HH:MM departure and arrival time for that trip. The departure time for each trip will be earlier than the arrival time. All arrivals and departures occur on the same day. The trips may appear in any order - they are not necessarily sorted by time. The hour and minute values are both two digits, zero-padded, and are on a 24-hour clock (00:00 through 23:59).After these NA lines, there are NB lines giving the departure and arrival times for the trips from B to A.

Output

For each test case, output one line containing “Case #x: ” followed by the number of trains that must start at A and the number of trains that must start at B.

Limits

1 ≤ N ≤ 100

Small dataset

0 ≤ NA, NB ≤ 20

0 ≤ T ≤ 5

Large dataset

0 ≤ NA, NB ≤ 100

0 ≤ T ≤ 60

Un poco de teoría - Porque VServer?

Existen muchos métodos de virtualizar un sistema operativo, con los mismos resultados, el poder simular varias computadoras en un solo hardware. El método más común (y mas costoso) es el de simular todo el hardware real o ficticio (Qemu, VirtualBox, etc). Su popularidad está basada a que ni el sistema operativo anfitrión ni el huésped necesita ninguna modificación.

Otro método utilizado para virtualizar consiste en pequeños drivers aplicados al anfitrión o húesped para miniminizar el trabajo adicional de simular el hardware para el húesped. Apesar del gran mejora aún se desperdicián recursos en la mediación entre el anfitrión y el huesped Las más populares implementaciones son UML y XEN.

La gran mayoría de las veces no se dese tener maquinas virtuales con sistemas operativos distintos, sino solo tener varias instancias de del mismo sistema operativo huésped, ya que la gran mayoría de las veces las aplicaciones no necesitan acceso directo al hardware o al kernel del sistema operativo. Para esa opción se puede usar el “chroot” de unix, pero también se puede obtener una solución más avanzada como ser VServer.

Para más detalles de la implementación de VServer pueden leer este Paper de su implementación (muy interesante)

Instalando VServer

Algunas personas critican a VServer porque el huésped necesita tener un kernel Linux “patcheado”, cosa que me parece críticas sin fundamentos, porque compilar el kernel es un juego de niños, con unos cuantos comandos y ~20 minutos (dependiendo del hardware) tendremos nuestro kernel listo para la virtualización. Para ello hay que bajar el patch necesario para la versión del kernel que se desea utilizar de la página de VServer.

wget "http://www.kernel.org/pub/linux/kernel/v2.6/linux-2.6.22.19.tar.bz2"
wget "http://ftp.linux-vserver.org/pub/kernel/vs2.2/patch-2.6.22.19-vs2.2.0.7.diff"
tar xfvj "linux-2.6.22.19.tar.bz2"
cd "linux-2.6.22.19"
patch -p1 < "../patch-2.6.22.19-vs2.2.0.7.diff"

Ahora ya tenemos preparado nuestro kernel, solo tenemos que configurarlo y compilarlo. El kernel viene con varias aplicaciones que facilitan su configuración, yo uso el menuconfig, pero existe varias otras opciones (make help ayudaría)

make menuconfig

Si puede ven en la lista principal VServer significa que “parchearon” correctamente su kernel, ahora tienen que elegir las opciones de VServer, aqui estan las opciones con las que compilé mi kernel (el Dynamic context id no me funcionó…)

Luego también puede personalizar su kernel sacando lo que no hace falta, y agregando atras necesarias que no estan incluidas por defecto. Una vez configurado el kernel hay que compilarlo (make help para mas info)

#compilamos todo
make all
#instalamos
make install
#reiniciamos
reboot

Luego si el sistema operativo inicia bien, ya terminamos con la parte mas complicada (que no es complicado) del proceso de instalación de VServer, ahora tenemos que instalar algunos utilitarios que nos ayudaran para crear a los huéspedes. Si son “redhateros” pueden hacer lo siguiente:

yum install util-vserver* -y

O si usan debian (no probé personalmente)

apt-get install util-vserver\*

Una vez instalado las aplicaciones *-vserver y con el kernel nuevo tenemos que testear si todo nos fue bien, para eso podemos hacer lo siguiente:

wget http://vserver.13thfloor.at/Stuff/SCRIPT/testme.sh
chmod +x testme.sh
./testme.sh

Si todo esta funcionando correctamente tendras que ver algo similar a esto:

Creando a los huespedes

Antes que nada existen varias formas de crear máquinas huésped, yo utilizo Yum para instalar los paquetes necesarios para el la distro huésped, para utilizar yum, necesita ser recompilado con un patch.

#!/bin/bash
NAME=virt01
HOSTNAME=virt01.foo-bar.com
#
ROOTDIR="/virtual/"
PKGBASE=$ROOTDIR/.pkg
VSERVER=$HOSTNAME
IP="eth0:192.168.1.106/24"
INTERFACE=$NAME
CONTEXT="43"
# por defecto VServer solo soporta hasta FC6,
# mas adelante escribiré como instalar versiones posteriores
# de Fedora
DIST="fc6"
PM="yum" 

/usr/sbin/vserver $VSERVER build -m $PM --context $CONTEXT --hostname=$HOSTNAME \
--interface $INTERFACE=$IP --rootdir $ROOTDIR --pkgbase $PKGBASE -- -d $DIST

Ahora tenemos una maquina huésped, y para comenzar a jugar con

#para iniciar la máquina virtual
vserver $NAME start
#para "entrar" a la máquina virtual
vserver $NAME enter
#para detener la máquina virtual
vserver $NAME stop
# ejecuta "something" en la máquina virtual
vserver $NAME exec something
# instalar algo en la máquina virtual
vyum $NAME -- install algo
# te queda la curiosidad?
man vserver

Algunas peculiaridades del VServer

VServer no cuenta con aislamiento de red, en vez de la virtualización, lo que en otras palabras significa que si la máquina huésped y el anfitrión utilizan una misma tarjeta pero diferentes IP, en realidad el IP de la máquina huésped es un Alias del IP del host. Claro que desde el huésped (por seguridad) solo se puede ver su IP. Esto es una gran punto a favor en rendimiento, ya que no hay desperdicios de tiempo en el CPU para la virtualización de los paquetes de red.

Sin embargo no todo es tan bueno, ya que generalmente los servicios que escuchan puertos, escuchan utilizando 0.0.0.0 (escucha en todo los IPs y alias de la máquina). Si que queremos tener httpd (o cualquier otro progama) instalado en el anfitrión y el huésped tenemos que fijarnos que desde el anfitrión no escuche desde el IP 0.0.0.0, para ver esto solo pueden ejecutar:

$ netstat -nlp | grep httpd
tcp        0      0 0.0.0.0:80                0.0.0.0:*                   LISTEN      2400/httpd

Si la httpd-anfitrión escucha 0.0.0.0:80, todas las consultas que le hagamos a nuestro httpd-huésped serán recibidas y procesadas por el http-anfitrión (por lo explicado anteriormente). Para solucionar el conflicto tendremos que forzar al httpd-anfitrión que escuche el IP-anfitrión. Si configuramos todo correctamente tendremos que ver algo similar a esto.

$ netstat -nlp | grep httpd
tcp        0      192.168.1.14:80                0.0.0.0:*                   LISTEN      2400/httpd

Debemos repetir el mismo proceso para cada aplicación que escucha el IP 0.0.0.0 y que queríamos ejecutar en el huésped y el anfitrión (eg: mysql, sshd, etc).

Lo que se viene

Conocí VServer gracias a que tuve la necesidad de virtualizar servidores en mi trabajo, y me encanto, ya que es muy similar a los Jails de FreeBSD, ademas que todo el filesystem del huésped es visto desde el anfitrión, ademas que las máquinas pueden compartir directorios entre si. Más adelante escribiré sobre como virtualizar servidores existentes, como instalar versiones más nuevas de Fedora, como forzar a vyum que lea desde el DVD de Fedora en vez de internet, esto es verdaderamente útil para instalaciones nuevas.

Espero que les haya gustado este introducción a VServer… espero sus comentarios con dudas o sugerencias.

Al parecer el hecho que el Dr. Stallman venga a nuestro país auspiciado por una Universidad Privada, no gusta a mucho a algunos “jakers”, que tiene un concepto errado de lo que es el software libre, por eso me tomé la molestia de tratar de explicar. En la página del movimiento GNU encontramos la definición del Sofware Libre cuatro libertades esenciales:

1. Libertad de usar el programa como queramos
2. Libertad de estudiar y cambiar el programa como queramos, para ello es necesario el acceso a los fuentes del programa.
3. Libertad de redistribuir el programa.
4. Libertad para distribuir nuestras versiones del programa.

En ninguna de esas libertades ni siquiera se insinúa que debemos odiar el dinero, o no aceptar ayudas que vienen del sector privado, ni mucho menos criticar a algunas personas que hacen todo lo posible para hacer las cosas bien, sabiendo que los que critican nunca, jamás hicieron nada por la comunidad del SL del Paraguay, ni mucho menos del mundo…

Me pregunto, que es esa moda de tener tal confusión a tal punto de odiar todo lo que genere dinero, que es ese pensamiento comunista, esas personas deberían mudarse a Cuba o a la China, para que sean plenamente felices. Acaso esas personas no trabajan en el sector privado?, acaso esas personas no tienen dinero? o por lo menos hicieron algún aporte a algún proyecto libre (en dinero o con códigos)?. Como Linus Torvalds dice “Talk is cheap, show me the code” hablar es fácil, lo que les falta es más acción.

Ojala entiendan que SL no es solamente instalar un sistema operativo y hacer algunos trucos en la consola.

Más textos sobre la “pelea”

Para tener una solución escribí una clase en php, llamado gCache, que ofrece una interfaz amigable para cachear fácilmente contenidos webs. En esta nueva versión que recién terminé soporta responder páginas comprimidas, que es bastante útil para ahorrar ancho de banda.

Aquí esta un ejemplo de uso:

<?php
include("gCache.php");
$cache = new gCache;
$cache->folder = "./cache/";
$cache->contentId="var45";
$cache->timeout = 1; /* 1 minuto */
/* gCache cachea toda la página */
/* entonces gCache puede decidir si enviar comprimido o no */
$cache->isPage=true;
if ($cache->Valid()) {
    echo $cache->content;
} else {
$cache->capture();
?>
<html>
<head>
<title>Cached page</title>
<head>
<body bgcolor="#CCCCCC">
    <h1>Testing Cesar D. Rodas' gCache Class</h1>
    <hr>
    <h2>Example of how to cache a hole page</h2>
    <hr>
<p>Basicaly what the gCache do, is to store a web-page or a portion of it into
  a<em> <em>cache file</em>. </em>The <em><em>cache file</em></em> has a $timeout
  in second of cache vitality, after that the cache will be re-created.</p>
<p>Also this class provides and locking system which is not depending of POSIX
  or other OS, this feature becomes to this class very portable.</p>
<hr>
<font size="1">This cache page was generated at
<?php echo date("Y/m/d H:i:s")?>
</font><font size="1"> by <a href="http://cesars.users.phpclasses.org/gcache">gCache</a>
</font>
</body>
</html>
<?
$cache->endcapture();
}
?>

Si se tiene mucha memoria RAM, optimizaría bastante que los caches que cambian frecuentemente sea hagan en un “RAM DISK” o tmpfs:

Manuel Lemos escribió en su blog otros consejos de como optimizar sitios webs.