Marcos Dione: dinant-0.5

I have a love and hate relantionship with regular expressions (regexps). On one side they're a very powerful tool for text processing, but on the other side of the coin, the most well known implementation is a language whose syntax is so dense, it's hard to read beyond the most basic phrases. This clashes with my intention of trying to make programs as readable as possible[1]. It's true that you can add comments and make your regexps span several lines so you can digest them more slowly, but to me it feels like eating dried up soup by the teaspoon directly from the package without adding hot water.

So I started reading regexps aloud and writing down how I describe them in natural language. This way, [a-z]+ becomes one or more of any of the letters between lowercase a and lowercase z, but of course this is way too verbose.

Then I picked up these descriptions and tried to come up with a series of names (in the Pyhton sense) that could be combined to build the same regexps. Even 'literate' programs are not really plain English, but a more condensed version, while still readable. Otherwise you end up with Perl, and not many think that's a good idea. So, that regexp becomes one_or_more(any_of('a-z')). As you can see, some regexp language can still be recognizable, but it's the lesser part.

So, dinant was born. It's a single source file module that implements that language and some other variants (any_of(['a-z'], times=[1, ]), etc). It also implements some prebuilt regexps for common constructs, like integer, a datetime() function that accepts strptime() patterns or more complex things like IPv4 or IP_port. Conforming I start using it in (more) real world examples (or issues are filed!), the language will slowly grow.

Almost accidentally, its constructive form brought along a nice feature: you can debug() your expression so you can find out the first sub expression that fails matching:

# this is a real world example!
In [1]: import dinant as d
In [2]: line = '''36569.12ms (cpu 35251.71ms)\n'''
# can you spot the error?
In [3]: render_time_re = ( d.bol + d.capture(d.float, name='wall_time') + 'ms ' +
...:                       '(cpu' + d.capture(d.float, name='cpu_time') + 'ms)' + d.eol )

In [4]: print(render_time_re.match(line))
None

In [5]: print(render_time_re.debug(line))
# ok, this is too verbose (I hope next version will be more human readable)
# but it's clear it's the second capture
Out[5]: '^(?P<wall_time>(?:(?:\\-)?(?:(?:\\d)+)?\\.(?:\\d)+|(?:\\-)?(?:\\d)+\\.|(?:\\-)?(?:\\d)+))ms\\ \\(cpu(?P<cpu_time>(?:(?:\\-)?(?:(?:\\d)+)?\\.(?:\\d)+|(?:\\-)?(?:\\d)+\\.|(?:\\-)?(?:\\d)+))'
# the error is that the text '(cpu' needs a space at the end

Of course, the project is quite simple, so there is no regexp optimizer, which means that the resulting regexpes are less readable than the ones you would had written by hand. The idea is that, besides debugging, you will never have to see them again.

Two features are in the backburner, and both are related. One is to make debugging easier by simply returning a representation of the original expression instead of the internal regexp used. That means, in the previous example, something like:

bol + capture(float, name='wall_time') + 'ms ' + '(cpu' + capture(float, name='cpu_time')

The second is that you can tell which types the different captured groups must convert to. This way, capture(float) would not return the string representing the float, but the actual float. The same for datetime() and others.

As the time of writing the project only lives on GitHub, but it will also be available in PyPI Any Time Soon®. Go grab it!


python ayrton


[1] for someone that knows how to read English, that is.

Manuel Kaufmann (Humitos): Diversidad, inclusión y todo eso

Atención, este artículo puede ser difícil de leer y fácil de juzgar. Sin embargo, me gustaría desahogarme y que podamos hablar de "lo prohibido" para que entre todos podamos construir una sociedad/comunidad mejor, sin prejuicios y en el que todos podamos hablar libremente sin ofender a los demás: entendiendo a todas las partes involucradas.

Como muchos sabrán, hace tiempo que venimos trabajando en "todo esto de la diversidad e inclusión" en el mundo de la programación. Sin embargo, yo, quien fue uno de los que empezó a impulsar esta idea entre mis conocidos (incluso antes de que Django Girls existiese) tengo un montón de dudas y problemas con este tema que es tan sensible.

Sí, dudas y problemas.

Luego de la PyConBr 13 hablé bastante con @turicas, a quien considero una persona sumamente abierta con la que se puede hablar sin problemas de los temas que nos molestan y de los problemas que tenemos. Él, luego de su charla en la que mencionó "Género y Número", me ayudó muchísimo a reflexionar sobre todo esto y a tratar de comprender un poco más la situación.

Es por eso que hoy me gustaría escribir todo lo que me quedó dando vueltas en la cabeza.

Me gustaría remontarme un poco a mi infancia, al lugar en el que fui criado y que me ayuden a entender un poquito porqué yo, entre tantas otras personas que queremos cambiar este mundo, tenemos estos problemas.

Nací en un barrio "normal" de Paraná, Entre Ríos, Argentina a una cuadra del río Paraná y rodeado por el mismo. El barrio tenía una única salida hacia "el centro" y había que caminar 5 cuadras para llegar a "la civilización" donde pasaban los buses, taxis y cualquier medio de transporte. En fin, yo pagaba $5 (en ese entonces ~USD 5) de taxi para llegar a ese lugar en vez de ir a pie por el miedo que tenía a que algo me ocurriese en el camino. El barrio, estaba "bien" en mi cuadra, pero esas otras 5 eran muy desoladas y rodeadas de "villas".

Ahí pasé toda mi infancia escuchando a los vecinos decir "estos negros de mierda" cuando a algunos de mis amigos cualquier persona le robaba las zapatillas, la bicicleta, la billetera o incluso nuestra pelota de fútbol (en general, la mayoría de los robos que hemos experimentado en mi barrio no han sido violentos). También, en reiteradas oportunidades nos entraron a robar a mi casa e incluso en una de ellas nosotros estábamos adentro.

Esas veces, "negros de mierda" era una expresión que se quedaba corta -según vecinos y familiares. En Paraná, donde nací yo, esta expresión tiene una connotación negativa y pésima que lamentablemente vive dentro de mí ya que me crié con esto.

En fin, lo que quiero decir en este punto es que incluso gente con la mente un poco abierta, que está a favor de la inclusión y la diversidad (como yo me considero) aún tiene este tipo de problemas. ¿Cuál es exactamente el problema? No estoy del todo seguro, pero al menos sé que ni siquiera nos sabemos expresar correctamente.

Personalmente, no tengo amigos de piel negra. Pero no es porque no quiera, al contrario. Sino que supongo que es simplemente porque en el lugar en el que yo nací "no es común": la mayoría de la gente es blanca leche (como yo) o de piel morena (esos a los que pésimamente le hemos llamado "negros de mierda" durante muchos años); pero de piel negra no hay.

¿Hasta acá, cómo vamos? Ya me odian. Espero que no. Todavía quiero seguir escribiendo sobre los problemas que tengo con respecto a "todo esto".

Pasemos al tema de la "diversidad de género". Anteriormente comenté un poco el trabajo que venimos haciendo organizando talleres Django Girls en diferentes países de Latinoamérica con el fin de acercar mujeres al mundo de la tecnología/programación y que se sientan cómodas. ¿Bien? Bueno, eso sería "diversidad de sexo" pero no de género, en realidad. Sexos hay solo 2, pero géneros hay algunos más. Hablemos un poco de eso.

Nuevamente me gustaría remontarme a la infancia. En esas épocas mientras estábamos jugando al fútbol si alguien te iba muy fuerte y a vos te dolía, la mayoría de los niños te decían cosas como: "ah, no seas mamita", "qué puto que sos", "maricón", "parecés mi hermana" y cosas similares. Eso, durante años.

Este tipo de frases, denotando una debilidad en el sexo femenino o burlándose de los homosexuales y demás va tomando su lugar en tu cabeza, en tu memoria... y ese tipo de expresiones pasan a ser una especie de "muletilla inconsciente" en ocasiones similares en tu adolescencia o madurez.

Lo mismo aquí. No tengo ningún amigo homosexual ni tampoco transexual. Resumiendo, no tengo ningún amigo que su sexo no coincida con su género o que no encaje en los "estándares religiosamente tradicionales". Pienso que probablemente haber vivido inmerso en este tipo de situaciones desde pequeño han hecho que frente a la posibilidad de ser parte de un grupo diverso, me distancie de estas personas (quizás consciente o quizás inconscientemente -hoy no lo sé)

Sigamos adelante, pero volvamos a lo que nos concierne: ¡queremos diversidad e inclusión en el ambiente en el que nos desenvolvemos! (¿verdad?) Bueno, en principio, creo que toda la gente que nos consideramos "abierta" necesitamos pensar bastante en esto nuevamente; pero más aún, creo que necesitamos pertenecer a estos grupos de las minorías y aprender de ellos. Una de las preguntas que les hago a las chicas que alcanzo a conocer un poquito más en los talleres de Django Girls o en las conferencias a las que asisto es: "¿Cómo es ser mujer en este evento/comunidad?" y "¿Has vivido alguna situación en la que te hayan dejado de lado en un trabajo o que ni siquiera te lo asignen por ser mujer? ¿Cómo fue? ¿Cómo se siente?".

Lamentablemente, incluso haciendo estas preguntas cuando tengo la oportunidad y creo que no voy a ofender a la otra persona, siento que sigo teniendo nada de información y todavía me cuesta comprender el problema. En varias oportunidades esto me hace pensar que quiero "ayudar a resolver" un problema que ni siquiera entiendo y al final del día me lo cuestiono y creo que estoy equivocado en el camino que estoy tomando.

En los últimos años he visitado varios países y he estado involucrado en diferentes comunidades y "siento" (quizás porque es la que más viví de cerca) que Argentina es el país con más discriminación, el país de la burla, del chiste fácil, del hacer quedar mal al otro en todo momento y en la mayoría de las veces, sin importar si le hacemos daño a la otra persona o no.

Hoy en día, creo que la gente "de grande" se está ubicando un poco más pero, ¿qué hacemos con todo eso que tenemos dentro de nuestra cabeza, en nuestra memoria y que muchas veces sale "sin querer"? Esto no es una excusa para llevarse todo por delante sin importar nada, al contrario, creo que lo que necesitamos es aprender de los demás (de los grupos diversos) a comportarnos, a expresarnos y crecer humanamente juntos: siendo parte.

Personalmente creo que esto es un problema de todos (inclusión y diversidad como un todo -lo otro aún no lo entiendo: no tengo idea lo que se siente ser parte de las minorías aún y quizás nunca lo logre sentir) y que todos necesitamos trabajar juntos. Juntos de verdad. No nosotros haciendo Django Girls por aquí, la gente de Afro Python haciendo eventos por allá y la comunidad Trans por otro lado. Eso creo que ayuda mucho, pero creo que lo ideal sería que empecemos a mezclarnos. Yo lo necesito. Yo, que quiero impulsar esto, lo necesito. Necesito esto porque necesito aprender de las minorías. Necesito verme forzado a cuidar mi lenguaje, a no discriminar, a bloquear toda esa infancia que llevo dentro y poder naturalmente hablar con todas las personas con respeto.

En fin, creo que para empezar a resolver la problemática de la diversidad y la inclusión lo que debemos hacer es justamente eso: participar de grupos diversos e inclusivos. Aunque eso suene tonto. Sin embargo, creo que si las personas que pertenecemos a los grupos de las mayorías, si no nos abrimos mentalmente y los grupos de las minorías nos aceptan, nos va a tomar mucho más tiempo poder seguir avanzando en erradicar esta problemática.

Estoy seguro que este artículo puede molestarle a algunas personas y pido disculpas anticipadamente por eso. Además, acepto un "sos un pelotudo" en los comentarios pero no sin una lección que me enseñe/ayude a entender el problema, me haga cuestionar mis pensamientos y me de pautas sobre como seguir creciendo.

Facundo Batista: Usando Go desde Python


¿Alguna vez necesitaron usar un código de Go desde Python? Yo sí, y acá cuento qué hice.

Antes que nada, un poco de background, para que el ejercicio no sea demasiado teórico: en el laburo tenemos que validar las licencias que se incluyen en el .snap, y aunque el formato en que están sería estándar (SPDX), una condición de contorno es usar el mismo parser/validador que se usa en snapd, para estar 107% seguros que el comportamiento va a ser el mismo hasta en los corner cases o bugs.

El detalle es que snapd está escrito en Go, y el server está escrito en Python. Entonces tengo que compilar ese código en Go y usarlo desde Python... de allí este post, claro.

Es más fácil de lo que parece, ya que el compilador de Go tiene la capacidad de buildear a "biblioteca compartida", y de ahí usarlo desde Python es casi trivial ("casi", porque tenemos que poner algo de código en C).

Para ser más claro, si queremos ejecutar "la lib de SPDX hecha en Go" desde nuestro Python, tenemos que poner dos componentes, que funcionan casi de adaptadores:

  • Un pequeño código en C para armar "como módulo" una funcioncita que recibe y entrega objetos Python, y hace la traducción al "mundo C" y llama a otra función en Go.
  • Un pequeño código en Go que traduce los parámetros desde C y llama a la biblioteca SPDX correspondiente.


Adaptador de Python a C

El archivo completo es spdx.c, paso a explicarlo haciendo antes la aclaración que es para Python 2 (que es lo que tenemos hoy en ese servicio), pero si fuera para Python 3 sería muy parecido (la idea es la misma, cambian algunos nombres, revisen acá).

Antes que nada, incluir la lib de Python

    #include <Python.h>

Vamos a llamar a una función de Go, necesitamos explicitar lo que va recibir (una cadena de bytes, que a nivel de C es un puntero a chars)  y lo que nos devuelve (un número, que interpretaremos como bool).

    long IsValid(char *);

Definimos la función que vamos a llamar desde Python... es sencilla porque es genérica, recibe self y argumentos, devuelve un objeto Python:

    static PyObject *
    is_valid(PyObject *self, PyObject *args)

El cuerpo de la función es sencillo también. Primero definimos 'source' (el string con la licencia a validar) y 'res' (el resultado), luego llamamos a PyArg_ParseTuple que nos va a parsear 'args', buscando una cadena ('s') la cual va a poner en 'source' (y si algo sale mal nos vamos enseguida, para eso está el 'if' alrededor).

    {
        char * source;
        long res;

        if (!PyArg_ParseTuple(args, "s", &source))
            return NULL;

Finalmente llamamos a IsValid (la función en Go), y a ese resultado lo convertimos en un objeto de Python tipo bool, que es lo que realmente devolvemos:

        res = IsValid(source);
        return PyBool_FromLong(res);
    }

Ahora que tenemos nuestra función útil, debemos meterla en un módulo, para lo cual tenemos que definir qué cosas van a haber en dicho módulo. Entonces, armamos la siguiente estructura, con dos lineas; la primera habla sobre nuestra función, la última es una marca en la estructura para que sepa que es el final.

    static PyMethodDef SPDXMethods[] = {
        {"is_valid", is_valid, METH_VARARGS, "Check if the given license is valid."},
        {NULL, NULL, 0, NULL}
    };

En la linea útil tenemos:

  • "is_valid": es el nombre de la función que vamos a usar desde afuera del módulo
  • is_valid: es una referencia a la función que tenemos definida arriba (para que sepa qué ejecutar cuando llamamos a "is_valid" desde afuera del módulo.
  • METH_VARARGS: la forma en que recibe los argumentos (fuertemente atado a como luego los parseamos con PyArg_ParseTuple arriba.
  • "Check ...": el docstring de la función.

Para terminar con este código, va el inicializador del módulo, con un nombre predeterminado ("init" + nombre del módulo), y la inicialización propiamente dicha, pasando el nombre del módulo y la estructura que acabamos de definir arriba:

    PyMODINIT_FUNC
    initspdx(void)
    {
        (void) Py_InitModule("spdx", SPDXMethods);
    }


Adaptador de C a Go

El archivo completo es spdxlib.go.

Tenemos que meter el código en un paquete 'main'

    package main

Importamos el código para SPDX de snapd (tienen que bajarlo antes con go get github.com/snapcore/snapd/spdx):

    import "github.com/snapcore/snapd/spdx"

Importamos adaptadores desde/a C, indicando que cuando buildeemos vamos a usarlo desde Python 2:

    // #cgo pkg-config: python2
    import "C"

La función propiamente dicha, donde indicamos que recibimos un puntero a char de C y vamos a devolver un bool:

    //export IsValid
    func IsValid(license *C.char) bool {

El cuerpo es nuevamente sencillo: llamamos al ValidateLicense de SPDX (convirtiendo primero la cadena a Go), y luego comparamos el resultado para saber si la licencia es válida o no:

        res := spdx.ValidateLicense(C.GoString(license))
        if res == nil {
            return true
        } else {
            return false
        }
    }

Cerramos con la definición obligatoria de main:

    func main() {}


Lo usamos

Primer paso, buildear (yo tengo Go 1.6, creo que necesitan 1.5 o superior para poder armar directamente la biblioteca compartida de C, pero no estoy seguro):

    go build -buildmode=c-shared -o spdx.so

Segundo paso, profit!

    $ python2
    >>> import spdx
    >>> spdx.is_valid("GPL-3.0")
    True

Facundo Batista: Trabajando en New York


Toda la semana pasada estuve también de viaje, aunque no de placer, sino de trabajo. De sprint, bah, como tantas otras veces.

Esta vez tocó New York, una ciudad bastante grande y conocida, pero a la que yo no había ido nunca. Así y todo de ciudad cosmopólita y una de las más "importantes" del mundo (atenti a las comillas) yo no tenía demasiada expectativas con el viaje.

Es que, como dije antes, era por laburo. Entonces uno no se arma de lugares para visitar y pasear, ya que no hay demasiado tiempo, normalmente. En este caso tuve la suerte que el horario de laburo fue 8:30-17:30, y sumado a que recién arrancaba el otoño, había luz bastante rato al salir cada día, entonces pude pasear más de lo que preví.

Restringido a adultos

Viejo taxi

Muchos carriles en el subte

Como me gusta a mí, estuve caminando un montón. Yendo de un lado para el otro, mirando la gente, etc. El domingo que llegué, ahí nomás, estuve caminando una hora sólo para llegar al restaurant donde íbamos a almorzar con Naty, Matias, y una pareja amiga de ellos.

Por otro lado, no me moví demasiaaaaaado de donde estaba el hotel. O sea, algunos kilómetros para acá, algunos kilómetros para acá, pero (casi) no salí de la isla de Manhattan, que es como la parte más monona de Nueva York.

Esquina típica

Estación Central

Mis primeras impresiones fueron... digitales. No, digo; mis primeras impresiones fue que había demasiada gente y demasiado ruido. Después me di cuenta que la ciudad huele feo, por todos lados, todo el tiempo. Y es cara, y hay poca luz.

En otras palabras, no me gustó New York. No todo es malo, eh. Tiene un parque fantástico (ver abajo), una vida cultural buenísima, la comida es decente (lo cual es bastante, para ser Estados Unidos), buenos bares, y un par de detalles más, pero en general, es una ciudad que no disfruté como otras.

Todo esto no evitó que pasee y conozca.

Contraste entre dos edificios

Una de las tardes me fui a caminar un rato por Chinatown (el barrio chino, bah... me quedo con los de Londres y Buenos Aires), que está pegado a una zona llamada "Little Italy" (Pequeña Italia), que tiene una interesante variedades de lugares para comer italiano. No me quedé por esa zona, porque mi idea era cenar en un local clásico de Nueva York: Katz.

Aunque es un restaurant famoso por ser sede de escenas de varias películas (la más famosa quizás fue el escandaloso orgasmo fingido por Meg Ryan en Cuando Harry conoció a Sally), mi intención era ir allí porque es uno de los mejores lugares para comer pastrami.

Barrio Chino

Pastrameeeeeeeeeeeee

No me volvió loco, el pastrami. Si lo tengo que describir, piensen en una tapa de asado ahumada y cocinada muy lento, tanto que se deshace completamente, con un sabor que parece un embutido rico. Fue algo totalmente nuevo para mí, a nivel comida: objetivo cumplido.

Algo que sí me gustó bastante fue el Central Park. Un espacio verde enorme, ahí en el medio de la ciudad, de los rascacielos y las avenidas. Como los bosques de Palermo, podrán pensar... bueno, como para ponerlo en perspectiva, el Central Park es OCHO veces más grande que los bosques de Palermo.

El viernes cortamos el laburo a la 4, y yo aproveché el extra de luz y me fuí para el parquecito. Llegué rápido (estaba a unas 10 o 15 cuadras) y estuve caminando hasta que se hizo de noche. Lo crucé a lo ancho, y no llegué ni a la mitad longitudinalmente hablando, pero todo lo que ví me gustó: un bosque, basicamente, con senderotes, senderos y senderitos, iluminado y cuidado.

Parque Central

Biblioteca de New York

El sábado tenía varias horas para pasear. Con Ricardo y Maxi nos tomamos un subte hasta el sur de Manhattan, y de ahí un ferry hasta la isla de enfrente, un paseito corto y piola para sacarle unas fotos a la Estatua de la Libertad. Cuando volvimos pegamos una vuelta por la parte financiera (Wall Street y eso), nos acercamos hasta el puente de Brooklyn (el cual empezamos a caminar, pero no cruzamos), y luego enfilamos para pegar un par de vueltas al Barrio Chino y a la Little Italy, donde merendamos en un café muy bueno (yo probé un capuchino y un cannolo a la siciliana, impecables).

En tu cara, toro

Manhattan, desde el ferry

Después no mucho más. Subte de vuelta al hotel, agarrar las valijas, juntarnos un grupito e ir a la parada del NYC Airporter, el micro que nos llevó al aeropuerto, checkin, espera, viaaaaaaje, y casita :).

Todas las fotos, acá.

Manuel Kaufmann (Humitos): Navegar en internet en aeropuertos

Una de las mejores cosas de saber cómo funcionan las cosas es que "a veces" podés utilizar ese conocimiento para tomar atajos.

Hoy tengo un ejemplo concreto de esto. En mi viaje por sudamérica creé un proyecto llamado PyFi Spot que básicamente es un portal cautivo escrito en Python que ejecuta comandos de iptables para permitir o denegar el acceso a internet de las personas que se conecta a una red abierta.

¿No les suena familiar? Esos bares, restaurantes o aeropuertos que te dicen que tenés 30 minutos gratis para navergar y luego se termina. OK, algunos aeropuertos te permiten pagar (nunca entedí dónde se compra ese usuario/contraseña que te pide al web) y podés seguir navegando durante el tiempo que has pagado. Pero hay otros, que ni siquiera tienen esa opción y entonces en una espera de 5 horas (como la mia de hoy) solo tenés 30 minutos y te querés matar.

Acá entran en juego macchanger y NetworkManager.

"Mmm... macchanger, eso me suena a algo", estarás pensando. Sí, la posta de este tipo de servicios es que bloquean a los dispositivos (teléfonos, laptops, etc) por el número de MAC de la placa de red de ese dispositivo que es único en el mundo. Entonces, esta es la forma que los portales tienen de saber quiénes están accediendo a su red y filtran el acceso a internet por ese número (que va incrustado en los paquetes de red).

Claro, ¿porqué sé esto? Porque me hice un programa que hace exactamente eso y le dediqué un par de semanas a estudiar como funcionaban estos bichos.

¿Entonces? ¿Cuál es la solución? Y claro, cada 29 minutos cambiar la MAC de tu placa de red y volverte a conectar utilizando la nueva MAC. El portal cautivo cree que sos una persona totalmente nueva y... ¡ADELANTE!

¿Cómo hago para cambiar la MAC? Utilicé Network Manager que hace todo esto sea muy fácil:

  • Click derecho en el ícono del systray
  • "Editar las conexiones..."
  • Elegís la conexión que tiene el nombre de la red del aeropuerto
  • Vas a la pestaña "Inalámbrica"
  • Y donde dice "Dirección MAC clonada", le ponés "Aleatorio"
  • Guardás todo, cerrás, volvés a conectar y listo!

Cookies en juego

Te recomiendo iniciar la sesión en el portal cautivo utilizando una pestaña privada, para así evitar que se guarden las cookies en tu máquina y que luego el sistema nos reconozca como que hemos vencido nuestro tiempo.

Si ya "la has cagao", borrando las cookies del navegador solucionás este problema.

Nota

A "macchanger" no lo usé al final, ya que si bien funcionó, al volverme a conectar a la red mediante "network manager" este me volvía a poner la MAC de mi placa de red original.

Facundo Batista: CDPedia, release y planes


Nueva versión

Hace unos diez días terminé de armar las imágenes para la nueva versión de la CDPedia, la 0.8.4 con contenido actualizado a Junio 2017, y la semana pasada hice los avisos correspondientes en todos lados menos acá.

Ya saben qué es la CDPedia, pero vuelvo a insistir: descárguenla, compártanla, difúndanla, ya que ayuda a que la mayor gente posible acceda a la Wikipedia y al conocimiento que la misma permite.

Vayan a la página oficial para ver cómo descargarla y otra info.

Esta versión no trae demasiadas novedades más que el contenido actualizado (que ya es bastante), pero también renové el contenido de la página de inicio, e hice varias mejoras a la hora de la generación de discos y tarballs, así como también en la calidad del código.

Velita en un festival de jazz en Baradero


Grupo de trabajo

Por otro lado, tengo ganas de mezclar dos cosas que me vienen dando vuelta en la cabeza: la idea de meter más gente a trabajar con CDPedia, y la de hacer algo de mentoring para que gente más nueva aprenda a programar (no sólo a nivel lenguaje, sino también las buenas prácticas, etc.).

Entonces, tengo la idea de armar un grupo de trabajo para CDPedia. Buscar tres o cuatro newbies, más quizás alguien con experiencia que me ayude, y ponernos a trabajar (de forma relajada, remota, pero más o menos constante) en CDPedia.

A nivel del proyecto a varias cosas al alcance de la mano, desde modernización del código y hacerlo más robusto en varias situaciones, hasta mejorar y normalizar los logs, preparar todo para Python 3, corregir bugs, etc.

Claro, la idea también ronda alrededor de las personas, los que participen del proyecto, que aprenderían Python en un nivel básico o intermedio, y obtendrían experiencia en trabajar en grupo de forma remota (y algo de presencial). También se haría foco en usar herramientas como control de versiones, manejo de issues/bugs, y prácticas modernas de desarrollo en general.

En algún punto es parecido a lo que en otro momento se llamó Adopte un Newbie, pero en este caso no hay una relación uno a uno entre mentor y participante, sino que sería un grupo donde cada integrante puede ayudar a otros, todos tutelados o guiados por mí (y como dije arriba, quizás alguien más), todo en un ambiente amigable y "seguro".

Fuente en el Cerro Santa Lucia, Santiago de Chile

Tengo que terminar de redondear la idea, especialmente a nivel operativa: composición del grupo (haría una búsqueda/oferta y luego una selección), formas de comunicación, ¿reuniones presenciales?, etc. También quiero definir la duración de la experiencia: quiero hacerla finita, y luego de alguna manera presentar los resultados con el grupo en alguna conferencia.

Ya les iré contando más novedades.

Facundo Batista: Paseando por Chile


El finde pasado nos fuimos con Moni a Chile, a pasear un poco.

Es el primer viaje que hacemos sin niños después de esta semana (si es que se puede considerar que ahí también estábamos todavía de a dos).

La gran ventaja de ir sin niños es que basicamente no teníamos que ocuparnos de nadie más que de nosotros :D. Íbamos a donde queríamos, comíamos a la hora que queríamos, nos levantábamos o acostábamos a la hora que queríamos, etc. Lo que hace una pareja sin hijos, bah...

Solos, en la escalera-piano

Paseamos a morir. Hicimos base en Santiago, pero todo un día lo pasamos en Valparaíso.

A Valparaíso fuimos y volvimos en micro. Cuando llegamos, lo primero que hicimos fue tomarnos un bondi hasta La Sebastiana, la casa que tenía Neruda en esa ciudad. La recorrimos con ayuda de una audioguía, ¡buenísimo! Nos encantó.

La Sebastiana vista desde afuera

Despues salimos y caminamos un montón, paseando, parando para almorzar, y seguimos caminando, recorriendo los cerros, subiendo por un funicular... en general muchas escaleras, muchas subidas y bajadas, ASÍ teníamos las pantorrillas...

Terminamos llegando al puerto, donde paseamos un poco por una feria e hicimos la merienda. Luego un trole hasta el centro de la ciudad, y el micro de vuelta a Santiago.

Esquina random de Valparaíso

La escalera del zapato, con una gran frase

Valparaíso vista desde arriba

Los otros tres días los pasamos en Santiago, aunque no fueron enteros por los viajes para llegar e irnos de Chile.

Paseamos bastante también, y no solamente por shoppings como parece ser costumbre de los argentinos que están por allá (?). Estaba toda la ciudad muy influenciada por las Fiestas Patrias, que es algo que allá es muy importante.

La cordillera siempre presente

Mural al lado de La Piojera

Paseamos un rato por el centro, pero justo el sábado y estaba todo bastante cerrado. Fuimos al Mercado Central también, en donde comimos ricas comidas basadas en pescados y mariscos.

También subimos al Cerro Santa Lucía, un lindo paseo que no completamos del todo porque no nos daba el tiempo restante para subir y recorrer todo el castillo que tiene en su parte superior. Pero paseamos por toda la zona y aledaños, así como también en el barrio de Bellavista, donde almorzamos en la Cervecería Kunstmann, super recomendable!

El paseo había arrancado en La Chascona, la casa de Neruda en Santiago. La visita (y recorrida con la audioguía) es algo que también aquí vale mucho la pena. Esta casa, como la que mencioné antes, y la de Isla Negra que nos debemos, son mantenidas y expuestas por la Fundación Neruda, y hacen un excelente trabajo.

Detalles de La Chascona

Si tengo que resaltar algo feo de Santiago/Valparaíso, además que la primera es una "ciudad grande" que a priori no me gustan, es que el cablerío que se ve en los postes en la calle es sorprendente, no se entiende como puede ser que hayan tantos cables ni para qué están. Parece ser que es porque los ponen y luego cuando los dejan de usar no los sacan, también parece que se va a solucionar eventualmente.

Lo otro que noté es que todo está pintarrajeado, a nivel grafiti/vandalismo. Pero no sólo paredes. Todo. Colectivos, ventanas de casas particulares, negocios pequeños y grandes. Todo.

Las fotos de todo el viaje, acá.  Con Moni tenemos que hacernos más de estas escapadas, son reconfortantes :)

Mariano Guerra: Multi-Paxos with riak_ensemble Part 3

In the previous post I showed how to use riak_ensemble in a rebar3 project, now I will show how to create an HTTP API for the Key/Value store using Cowboy and jsone.

This post assumes that you have erlang and rebar3 installed, I'm using erlang 19.3 and rebar3 3.4.3.

The source code for this post is at https://github.com/marianoguerra/cadena check the commits for the steps.

Dependency Setup

To have an HTTP API we will need an HTTP server, in our case we will use Cowboy 2.0 RC 3, for that we need to:

  1. Add it as a dependency (we will load if from git since it's still a release candidate)
  2. Add it to our list of applications to start when our application starts
  3. Add it to the list of dependencies to include in our release
  4. Set up the HTTP listener and routes when our application starts

We setup just one route that is handled by the cadena_h_keys module, it's a plain HTTP handler, no fancy REST stuff for now, there we handle the request on the init/2 function itself, we pattern match against the method field on the request object and handle:

POST
set a key in a given ensemble to the value sent in the JSON request body
GET
get a key in a given ensemble, if not found null will be returned in the value field in the response
DELETE
delete a key in a given ensemble, returns null both if the key existed and if itdidn't

Any other method would get a 405 Method Not Allowed response.

The route has the format /keys/<ensemble>/<key>, for now we only allow the root ensemble to be set in the <ensemble> part of the path.

We also add the jsone library to encode/decode JSON and the lager library to log messages.

We add both to the list of dependencies to include in the release.

We will also need to have a way to override the HTTP port where each instance listens to so we can run a cluster on one computer and each node can listen for HTTP requests on a different port.

The dev and prod releases will listen on 8080 as specified in vars.config.

node1 will listen on port 8081 (override in vars_node1.config)

node2 will listen on port 8082 (override in vars_node2.config)

node3 will listen on port 8083 (override in vars_node3.config)

To avoid having to configure this in sys.config we will define a cuttlefish schema in config.schema that cuttlefish will use to generate a default config file and validation code for us.

We have to replace the variables from variable overrides in our config.schema file for each release before it's processed by cuttlefish itself, for that we use the template directive on an overlay section on the release config.

Build devrel:

make revrel

Check the configuration file generated for each node at:

_build/node1/rel/cadena/etc/cadena.conf
_build/node2/rel/cadena/etc/cadena.conf
_build/node3/rel/cadena/etc/cadena.conf

The first part is of interest to us, it looks like this for node1, the port number is different in node2 and node3:

## port to listen to for HTTP API
##
## Default: 8081
##
## Acceptable values:
##   - an integer
http.port = 8081

## number of acceptors to user for HTTP API
##
## Default: 100
##
## Acceptable values:
##   - an integer
http.acceptors = 100

## folder where ensemble data is stored
##
## Default: ./cadena_data
##
## Acceptable values:
##   - text
data.dir = ./cadena_data

Start 3 nodes in 3 different shells:

make node1-console
make node2-console
make node3-console

Start enseble and join nodes, I created a target called devrel-setup in the Makefile to make it easier:

make devrel-setup

Let's set key1 in ensemble root to 42 on node1 (port 8081):

curl -X POST http://localhost:8081/keys/root/key1 -d 42

Response:

{"data":{"epoch":2,"key":"key1","seq":10,"value":42},"ok":true}

Let's get key1 in ensemble root to 42 on node2 (port 8082):

curl -X GET http://localhost:8082/keys/root/key1

Response:

{"data":{"epoch":2,"key":"key1","seq":10,"value":42},"ok":true}

Same on node3:

curl -X GET http://localhost:8083/keys/root/key1

Response:

{"data":{"epoch":2,"key":"key1","seq":10,"value":42},"ok":true}

Overwrite on node1:

curl -X POST http://localhost:8081/keys/root/key1 -d '{"number": 42}'

Response:

{"data":{"epoch":2,"key":"key1","seq":400,"value":{"number":42}},"ok":true}

Get on node2:

curl -X GET http://localhost:8082/keys/root/key2
{"data":{"epoch":3,"key":"key2","seq":11,"value":null},"ok":true}

Let's set key2 in ensemble root to {"number": 42} on node1 (port 8081):

curl -X POST http://localhost:8081/keys/root/key2 -d '{"number": 42}'

Response:

{"data":{"epoch":3,"key":"key2","seq":67,"value":{"number":42}},"ok":true}

Get it on node2:

curl -X GET http://localhost:8082/keys/root/key2

Response:

{"data":{"epoch":3,"key":"key2","seq":67,"value":{"number":42}},"ok":true}

Delete key2 in ensemble root on node2:

curl -X DELETE http://localhost:8082/keys/root/key2

Response:

{"data":{"epoch":3,"key":"key2","seq":137,"value":null},"ok":true}

Check that it was removed by trying to get it again on node2:

curl -X GET http://localhost:8082/keys/root/key2

Response:

{"data":{"epoch":3,"key":"key2","seq":137,"value":null},"ok":true}

There you go, now you have a Consistent Key Value Store with an HTTP API.

Mariano Guerra: Multi-Paxos with riak_ensemble Part 2

In the previous post I showed how to use riak_ensemble from the interactive shell, now I will show how to use rebar3 to use riak_ensemble from a real project.

This post assumes that you have erlang and rebar3 installed, I'm using erlang 19.3 and rebar3 3.4.3.

The source code for this post is at https://github.com/marianoguerra/cadena check the commits for the steps.

Create Project

rebar3 new app name=cadena
cd cadena

The project structure should look like this:

.
├── LICENSE
├── README.md
├── rebar.config
└── src
        ├── cadena_app.erl
        ├── cadena.app.src
        └── cadena_sup.erl

1 directory, 6 files

Configuring Dev Release

We do the following steps, check the links for comments on what's going on for each step:

  1. Add Dependencies
  2. Configure relx section
    1. Add overlay variables file vars.config
    2. Add sys.config
    3. Add vm.args

Build a release to test that everything is setup correctly:

$ rebar3 release

Run the release interactively with a console:

$ _build/default/rel/cadena/bin/cadena console

Output (edited and paths redacted for clarity):

Exec: erlexec
        -boot _build/default/rel/cadena/releases/0.1.0/cadena
        -boot_var ERTS_LIB_DIR erts-8.3/../lib
        -mode embedded
        -config    _build/default/rel/cadena/generated.conf/app.1.config
        -args_file _build/default/rel/cadena/generated.conf/vm.1.args
        -vm_args   _build/default/rel/cadena/generated.conf/vm.1.args
        -- console

Root: _build/default/rel/cadena
Erlang/OTP 19 [erts-8.3] [source] [64-bit] [smp:4:4] [async-threads:64]
                      [kernel-poll:true]

18:31:12.150 [info] Application lager started on node 'cadena@127.0.0.1'
18:31:12.151 [info] Application cadena started on node 'cadena@127.0.0.1'
Eshell V8.3  (abort with ^G)
(cadena@127.0.0.1)1>

Quit:

(cadena@127.0.0.1)1> q().
ok

Non interactive start:

$ _build/default/rel/cadena/bin/cadena start

No output is generated if it's started, we can check if it's running by pinging the application:

$ _build/default/rel/cadena/bin/cadena ping

We should get:

pong

If we want we can attach a console to the running system:

$ _build/default/rel/cadena/bin/cadena attach

Output:

Attaching to /tmp/erl_pipes/cadena@127.0.0.1/erlang.pipe.1 (^D to exit)

(cadena@127.0.0.1)1>

If we press Ctrl+d we can dettach the console without stopping the system:

(cadena@127.0.0.1)1> [Quit]

We can stop the system whenever we want issuing the stop command:

$ _build/default/rel/cadena/bin/cadena stop

Output:

ok

Note

Use Ctrl+d to exit, if we write q(). not only we dettach the console but we also stop the system!

Let's try it.

Non interactive start:

$ _build/default/rel/cadena/bin/cadena start

No output is generated if it's started, we can check if it's running by pinging the application:

$ _build/default/rel/cadena/bin/cadena ping

We should get:

pong

If we want we can attach a console to the running system:

$ _build/default/rel/cadena/bin/cadena attach

Output:

Attaching to /tmp/erl_pipes/cadena@127.0.0.1/erlang.pipe.1 (^D to exit)

(cadena@127.0.0.1)1>

Now let's quit with q():

(cadena@127.0.0.1)1> q().

Output:

ok

Now let's see if it's alive:

$ _build/default/rel/cadena/bin/cadena ping

Node 'cadena@127.0.0.1' not responding to pings.

Be careful with how you quit attached consoles in production systems :)

Configure Prod and Dev Cluster Releases

Building Prod Release

We start by adding a new section to rebar.config called profiles, and define 4 profiles that override the default release config with specific values, let's start by trying the prod profile, which we will use to create production releases of the project:

rebar3 as prod release

Output:

===> Verifying dependencies...
...
===> Compiling cadena
===> Running cuttlefish schema generator
===> Starting relx build process ...
===> Resolving OTP Applications from directories:
          _build/prod/lib
          erl-19.3/lib
===> Resolved cadena-0.1.0
===> Including Erts from erl-19.3
===> release successfully created!

Notice now that we have a new folder in the _build directory:

$ ls -1 _build

Output:

default
prod

The results of the commands run "as prod" are stored in the prod folder.

You will notice if you explore the prod/rel/cadena folder that there's a folder called erts-8.3 (the version may differ if you are using a different erlang version), that folder is there because of the include_erts option we overrided in the prod profile.

This means you can zip the _build/prod/rel/cadena folder, upload it to a server that doesn't have erlang installed in it and still run your release there.

This is a good way to be sure that the version running in production is the same you use in development or at build time in your build server.

Just be careful with deploying to an operating system too different to the one you used to create the release becase you may have problems with bindings like libc or openssl.

Running it is done as usual, only the path changes:

_build/prod/rel/cadena/bin/cadena console

_build/prod/rel/cadena/bin/cadena start
_build/prod/rel/cadena/bin/cadena ping
_build/prod/rel/cadena/bin/cadena attach
_build/prod/rel/cadena/bin/cadena stop

Building Dev Cluster Releases

To build a cluster we need at least 3 nodes, that's why the last 3 profiles are node1, node2 and node3, they need to have different node names, for that we use the overlay var files to override the name of each, that is achieved on config/vars_node1.config for node1, config/vars_node2.config for node2 and config/vars_node3.config for node3.

Now let's build them:

rebar3 as node1 release
rebar3 as node2 release
rebar3 as node3 release

The output for each should be similar to the one for the prod release.

Now on three different shells start each node:

./_build/node1/rel/cadena/bin/cadena console

Check the name of the node in the shell:

(node1@127.0.0.1)1>

Do the same for node2 and node3 on different shells:

./_build/node2/rel/cadena/bin/cadena console
./_build/node3/rel/cadena/bin/cadena console

You should get respectively:

(node2@127.0.0.1)1>

And:

(node3@127.0.0.1)1>

In case you don't remember, you can quit with q().

Joining the Cluster Together

Until here we built 3 releases of the same code with slight modifications to allow running a cluster on one computer, but 3 nodes running doesn't mean we have a cluster, for that we need to use what we learned in the Multi-Paxos with riak_ensemble Part 1 but now on code and not interactively.

For that we will create a cadena_console module that we will use to make calls from the outside and trigger actions on each node, the code is similar to the one presented in Multi-Paxos with riak_ensemble Part 1.

join([NodeStr]) ->
    % node name comes as a list string, we need it as an atom
    Node = list_to_atom(NodeStr),
    % check that the node exists and is alive
    case net_adm:ping(Node) of
        % if not, return an error
        pang ->
            {error, not_reachable};
        % if it replies, let's join him passing our node reference
        pong ->
            riak_ensemble_manager:join(Node, node())
    end.

create([]) ->
    % enable riak_ensemble_manager
    riak_ensemble_manager:enable(),
    % wait until it stabilizes
    wait_stable().

cluster_status() ->
    case riak_ensemble_manager:enabled() of
        false ->
            {error, not_enabled};
        true ->
            Nodes = lists:sort(riak_ensemble_manager:cluster()),
            io:format("Nodes in cluster: ~p~n",[Nodes]),
            LeaderNode = node(riak_ensemble_manager:get_leader_pid(root)),
            io:format("Leader: ~p~n",[LeaderNode])
    end.

We also need to add the riak_ensemble supervisor to our supervisor tree in cadena_sup:

init([]) ->
    % get the configuration from sys.config
    DataRoot = application:get_env(riak_ensemble, data_root, "./data"),
    % create a unique path for each node to avoid clashes if running more
    % than one node in the same computer
    NodeDataDir = filename:join(DataRoot, atom_to_list(node())),

    Ensemble = {riak_ensemble_sup,
                {riak_ensemble_sup, start_link,
                 [NodeDataDir]},
                permanent, 20000, supervisor, [riak_ensemble_sup]},

    {ok, { {one_for_all, 0, 1}, [Ensemble]} }.

Before building the dev cluster we need to add the crypto app to cadena.app.src since it's needed by riak_ensemble to create the cluster.

Now let's build the dev cluster, I created a Makefile to make it simpler:

make devrel

On three different shells run one command on each:

make node1-console
make node2-console
make node3-console

Let's make an rpc call to enable the riak_ensemble cluster on node1:

./_build/node1/rel/cadena/bin/cadena rpc cadena_console create

On node1 you should see something like:

[info] {root,'node1@127.0.0.1'}: Leading

Let's join node2 to node1:

./_build/node2/rel/cadena/bin/cadena rpc cadena_console join node1@127.0.0.1

On node1 you should see:

[info] join(Vsn): {1,152} :: 'node2@127.0.0.1' :: ['node1@127.0.0.1']

On node2:

[info] JOIN: success

Finally let's join node3:

./_build/node3/rel/cadena/bin/cadena rpc cadena_console join node1@127.0.0.1

Output on node1:

[info] join(Vsn): {1,453} :: 'node3@127.0.0.1' :: ['node1@127.0.0.1','node2@127.0.0.1']

On node3:

[info] JOIN: success

Let's check that the 3 nodes have the same view of the cluster, let's ask node1 what's the ensemble status:

./_build/node1/rel/cadena/bin/cadena rpc cadena_console ensemble_status
Nodes in cluster: ['node1@127.0.0.1','node2@127.0.0.1','node3@127.0.0.1']
Leader: 'node1@127.0.0.1'

node2:

$ ./_build/node2/rel/cadena/bin/cadena rpc cadena_console ensemble_status
Nodes in cluster: ['node1@127.0.0.1','node2@127.0.0.1','node3@127.0.0.1']
Leader: 'node1@127.0.0.1'

node3:

$ ./_build/node3/rel/cadena/bin/cadena rpc cadena_console ensemble_status
Nodes in cluster: ['node1@127.0.0.1','node2@127.0.0.1','node3@127.0.0.1']
Leader: 'node1@127.0.0.1'

Everything looks right, stop the 3 nodes (q().) and start them again, you will see that after starting up node1 logs:

[info] {root,'node1@127.0.0.1'}: Leading

And if you call ensemble_status on any node you get the same outputs as before, this means they remember the cluster topology even after restarts.

Mariano Guerra: Public/Private Key Encryption, Sign and Verification in Erlang

You want to encrypt/decrypt some content?

You want to generate a signature and let others verify it?

At least that's what I wanted to do, so here it is.

First generate keys if you don't have some available:

openssl genrsa -out private.pem 2048
openssl rsa -in private.pem -out public.pem -outform PEM -pubout

Load the raw keys:

{ok, RawSKey} = file:read_file("private.pem").
{ok, RawPKey} = file:read_file("public.pem").

[EncSKey] = public_key:pem_decode(RawSKey).
SKey = public_key:pem_entry_decode(EncSKey).

[EncPKey] = public_key:pem_decode(RawPKey).
PKey = public_key:pem_entry_decode(EncPKey).

Let's encrypt a message with the private key and decrypt with the public key:

Msg = <<"hello crypto world">>.
CMsg = public_key:encrypt_private(Msg, SKey).
Msg = public_key:decrypt_public(CMsg, PKey).

We can do it the other way, encrypt with the public key and decrypt with the private key:

CPMsg = public_key:encrypt_public(Msg, PKey).
Msg = public_key:decrypt_private(CPMsg, SKey).

Let's generate a signature for the message that others can verify with our public key:

Signature = public_key:sign(Msg, sha256, SKey).
public_key:verify(Msg, sha256, Signature, PKey).

% let's see if it works with another message
public_key:verify(<<"not the original message">>, sha256, Signature, PKey).