Deshacer el push en git

Actualizacion: Quick fix

Alguien pusheo commits que no debia, o por alguna razon se pretende "deshacer" commits que ya se enviaron al servidor central.

Quick fix

Buscar el commit a donde se pretende volver: (usar git log o git reflog, etc...), y despues hay que ejecutar estos commandos (donde a_donde_volver se reemplaza por el commit):

git reset a_donde_volver
git checkout HEAD .
git push --force

Y a trabajar

NOTA: usar --force solo para casos especificos como este, ya que directamente sobreescribe cambios en la rama remota (que es lo que se pretende hacer en este caso)

Narrado (for dummys)

Todo lo que voy a explicar es asumiendo que se esta trabajando en la rama master (que es la default en git), si no estas trabajando en la rama master, el comando "git branch" muestra la rama de trabajo en la que estas trabajando

Antes, que nada, se puede hacer un tag del master actual:

git tag ultimo_master master

Posteriormente, hay que encontrar el commit al cual se quiere volver, se pueden revisar los logs (el nombre de la rama es opcional, si no se indica usa la rama de trabajo actual):

git log [master]

Supongamos que el commit al que se quiere volver es 0123456789abcd..., puede ser util taguearlo para referenciaro facilmente mas adelante (aunque se puede hacer todo referenciando al commit, directamente)

git tag a_donde_volver 0123456789abcd...

Posteriormente, se hace un reset a para que la rama master local referencie a ese commit, y despues un checkout para cambiar los archivos y que coincidan

git reset a_donde_volver
git checkout HEAD .

Despues, hay que sobreescribir la referencia master remota con la actual, pero hay que usar --force para que git no verifique si se trata de un fast-forward (porque sino rechaza la operacion), recordar usar --force solamente en casos especificos como este.

git push --force

Y despues se puede seguir trabajando normalmente

Bonus track

Puede ser util crear un branch en el servidor a partir del master original antes de que se revierta (para poder analizarlo entre todos, etc...), para hacer esto:

git push origin ultimo_master:refs/heads/old_master

Y en este post explico como usar los branches:

http://nilclass.blogspot.com/2009/08/branches-remotos-en-git.html

Solucion a sectores dañados en linux. EXT2 y EXT3

Sintomas

El sistema se cuelga en tareas estupidas como reproducir una pelicula, instalar paquetes, configurar cosas, abrir determinados archivos para despues de un tiempo de estar "colgado" anunciar que hasta la tarea mas simple fallo por un "I/O error".

Hace falta confirmarlo tambien con los logs, la informacion necesaria aparece en el syslog (en /var/log/syslog ), se encontraran lineas similares a estas:

Jun 16 16:17:56 ubuntu kernel: [ 6193.840250] Buffer I/O error on device sda1, logical block 155153547
Jun 16 16:17:56 ubuntu kernel: [ 6193.840254] Buffer I/O error on device sda1, logical block 155153548
Jun 16 16:17:56 ubuntu kernel: [ 6193.840258] Buffer I/O error on device sda1, logical block 155153549

O tambien de estas:

Jun 15 20:16:01 ubuntu kernel: [   25.636424] ata1.00: status: { DRDY ERR }
Jun 15 20:16:01 ubuntu kernel: [   25.640935] ata1.00: configured for UDMA/133
Jun 15 20:16:01 ubuntu kernel: [   25.640951] ata1: EH complete
Jun 15 20:16:01 ubuntu kernel: [   29.172011] ata1.00: exception Emask 0x0 SAct 0x7fff SErr 0x0 action 0x0
Jun 15 20:16:01 ubuntu kernel: [   29.172013] ata1.00: irq_stat 0x40000008
Jun 15 20:16:01 ubuntu kernel: [   29.172016] ata1.00: failed command: READ FPDMA QUEUED
Jun 15 20:16:01 ubuntu kernel: [   29.172022] ata1.00: cmd 60/08:28:a7:74:3f/00:00:09:00:00/40 tag 5 ncq 4096 in
Jun 15 20:16:01 ubuntu kernel: [   29.172025] ata1.00: status: { DRDY ERR }
Jun 15 20:16:01 ubuntu kernel: [   29.176722] ata1.00: configured for UDMA/133
Jun 15 20:16:01 ubuntu kernel: [   29.176740] ata1: EH complete
Jun 15 20:16:01 ubuntu kernel: [   32.440790] ata1.00: exception Emask 0x0 SAct 0x7fab SErr 0x0 action 0x0
Jun 15 20:16:01 ubuntu kernel: [   32.440792] ata1.00: irq_stat 0x40000008
Jun 15 20:16:01 ubuntu kernel: [   32.440795] ata1.00: failed command: READ FPDMA QUEUED
Jun 15 20:16:01 ubuntu kernel: [   32.440801] ata1.00: cmd 60/08:48:a7:74:3f/00:00:09:00:00/40 tag 9 ncq 4096 in
Jun 15 20:16:01 ubuntu kernel: [   32.440805] ata1.00: status: { DRDY ERR }
Jun 15 20:16:01 ubuntu kernel: [   32.440807] ata1.00: error: { UNC }
Jun 15 20:16:01 ubuntu kernel: [   32.445770] ata1.00: configured for UDMA/133
Jun 15 20:16:01 ubuntu kernel: [   32.445785] ata1: EH complete

Solucion

Si algunos sectores del disco estan dañados sera inevitable que se pierda el disco entero tarde o temprano, por eso lo primero que se debe hacer es backup de toda la informacion.
Posteriormente, para poder seguir usando el disco, se debe hacer una revision completa marcando los bloques dañados como tal, el comando que hay que ejecutar es:

e2fsck -c /dev/sda1

Reemplazando /dev/sda1 por la particion que tengan que reparar.

Esto solo se puede hacer con la particion desmontada, para poder hacerlo asi recomiendo una de tres opciones:

1) Usar un live-cd como los de ubuntu, que les permite acceder a las particiones, tienen los comandos basicos y hasta entorno grafico para que puedan, por ej, escribir articulos en su blog publicando la solucion (es mi caso)

2) Usar una opcion de "rescue" (no estoy seguro si viene con ubuntu, pero viene con todos los fedora) eso les da una shell con privilegios de root pero nada de graficos, de ventanitas de gelatina, ni menos cubos de escritorio girando

3) Inician el sistema normalmente, y con Ctrl+Alt+F1 pasan a la consola sin graficos, ejecutan:

sudo init 1

Para pasar a runlevel 1 que detiene todos los servicios (incluyendo el entorno grafico) y permite desmontar cualquier particion, ahi ejecutan el escaneo y cuando termine vuelven a montar la particion y hacen

sudo init 5

Para volver a runlevel 5

Esta ultima es mas para "hackers" pero es innecesariamente complicada y me fracture el dedo indice cuando quise hacerla.

Renovado diseño del blog

Tarde de domingo sin saber que hacer, renovacion visual del blog. Se hicieron los siguientes cambios.

* Se cambiaron los colores blancos, claros de blogs de psicologia newbies por colores darks, bizarros propios del underground, el H4X0R1NG, el KRAK0RING y PRHEKIRING aunque el blog NO PUBLICARA ARTICULOS DE ESA CATEGORIA :P (para eso hay blogs muy buenos en la web)

* Se cambiaron los colores del syntax highlighting en el style para que tenga sentido con los nuevos colores (todo dark) y se incluyo el style como tag en el template del blog para acelerar la carga de la pagina

* Se incluyeron todos los Javascripts de highlighting en el template del blog (en los tags ) en lugar de que sean referencia remota al sitio donde estaban alojados, con esto se acelera por mucho la carga de la pagina.

* Se cambio el fondo por uno de esos fondos "geeks" que hay en las opciones, pero como esto es ruby, se pinto de rojo (el original era azul)

Lo que mas me ayudo fue el plugin firebug para probar como quedan los colores antes de grabar en el template, y analizar un poco el source code de la pagina.
Tambien me sirvio bastante el irb para escapear el javascript, la libreria CGI:

require "cgi"
CGI.escapeHTML("<script>alert('hello world')</script>");
# => "&lt;script&gt;alert('hello world')&lt;/script&gt;"

Espero que la experiencia blogger sea mas ruby ahora

Definicion de clases y metodos en un eval

Una de las miles de cualidades que tiene ruby como lenguaje dinamico es la ejecucion de codigo ruby contenido en un string mediante el uso de la funcion eval.
Asi se pueden hacer cosas bastante interesantes ejecutando codigo ingresado dinamicamente ^_^
No obstante es necesario conocer como sortear determinados obstaculos en la ejecucion de codigo dinamico

class Runner
    def run(code)
        eval(code)
    end
end

runner = Runner.new

# ¡¡FAIL!! :(, no se puede definir classes desde adentro de un metodo (Runner#run)
runner.run("
    class X
        def foo
            print \"hello world\n\"
        end
    end
    
    x = X.new
    x.foo
    ")

Lo que se intento hacer en el ejemplo anterior, para el interprete es equivalente a:

class Runner
    def run(code)
       # いけない！!! 
       # en ruby no esta permitido definir clases adentro de metodos
       # (aunque si permite hacer otras cosas locas XD )
       class X 
           def foo
                print \"hello world\n\"
           end
       end
    
       x = X.new
       x.foo
    end
end

Para poder hacerlo correctamente hay que pasarle un segundo parametro a eval que es el "binding", un binding representa el contexto en ruby de donde se llama el binding, que incluye las variables locales, etc... mejor verlo en el ejemplo que explicarlo:

class Runner
    
    class << self
        attr_accessor :runner_binding
    end
    
    def run(code)
        # se especifica un binding al eval para definir el contexto
        # en el que se ejecuta el codigo
        eval(code, Runner.runner_binding)
    end
end

# se copia el binding del contexto actual (fuera de cualquier clase o metodo)
Runner.runner_binding = binding

runner = Runner.new

# se puede definir clases en el codigo pasado a eval, porque el binding
# esta afuera de cualquier declaracion de clase o metodo y el eval se
# llama con ese binding
runner.run("
    class X
        def foo
            print \"hello world\n\"
        end
    end
    
    x = X.new
    x.foo
    ")
    
    

Que para el interprete es lo mismo que reemplazar el codigo en donde se llama a binding en lugar de en donde se llama a eval:

class Runner
    
    class << self
        attr_accessor :runner_binding
    end
    
    def run(code)
        # se especifica un binding al eval para definir el contexto
        # en el que se ejecuta el codigo
        eval(code, Runner.runner_binding)
    end
end

# よろしい
# Runner.runner_binding = binding
    class X
        def foo
            print \"hello world\n\"
        end
    end
    
    x = X.new
    x.foo

    

Y ya que estamos, les cuento que otra cosa tiene el eval para hacer

def bar
  1/0 # ZeroDivisionError
end

def foo(code) # ¿porque siempre foo?
eval(code)
end

foo("bar") # 

Resultado:

test.rb:6:in `foo': test.rb:2:in `/': divided by 0 (ZeroDivisionError)
 from test.rb:2:in `bar'
 from (eval):1:in `foo'
 from test.rb:9:in `eval'
 from test.rb:6:in `foo'
 from test.rb:9

Mejor, pasarle unos argumentos adicionales a eval especificando el "archivo" y el numero de linea de donde viene el codigo evaluado

def bar
  1/0 # ZeroDivisionError
end

def foo(code) # ¿porque siempre foo?
eval(code, binding, "foo_eval.rb", 1)
end

foo("bar") # 

Resultado:

test.rb:2:in `/': divided by 0 (ZeroDivisionError)
 from test.rb:2:in `bar'
 from foo_eval.rb:1:in `foo'
 from test.rb:6:in `foo'
 from test.rb:9

Ahora se puede ver mejor en el backtrace de donde viene el codigo, con esto mejorada la trazabilidad cuando se usa eval.

¡Cuidado! Pizza Radioctiva

Ficha tecnica:

Radiancia: 5.9 Kilopluts a temp. ambiente
Queso: 1.8 Kilogramos
Tomate: 4.5 Terawatts

Aceitunotones nominal: 2 (ya disipados)
Vida Media: 9 minutos desde la salida del horno

Como escribir una extension ruby en C en 5 minutos

Lo siguiente toma lugar entre las 15:51 pm y las 15:56 pm

Para crear una extension en ruby lo primero que hay que hacer, es crear el "extconf.rb", basicamente tiene que tener el siguiente contenido:

# extconf.rb
require 'mkmf'

dir_config("exttest")

create_makefile("exttest")

Posteriormente, hay que crear el archivo del codigo fuente en C de la extension, que minimamente tiene que haber uno, en este caso creamos uno de prueba, bastante resumido, el cual crea un modulo ruby y le define dos metodos, ambos implementados en C:

// exttest.c

#include "ruby.h"

static VALUE foo(VALUE self) {
 printf("Foo invoqued\n");
 return Qnil;
}

static VALUE sum(VALUE self, VALUE a, VALUE b) {
 return INT2NUM( NUM2INT(a) + NUM2INT(b) );
}


void
Init_exttest()
{
 VALUE rb_exttest = rb_define_module("Exttest"); // definir el modulo
 
 rb_define_singleton_method(rb_exttest, // en que modulo
   "foo", // nombre del metodo
   foo, // puntero a la implementacion C del metodo
   0 // cantidad de argumentos del metodo
   );

 rb_define_singleton_method(rb_exttest, // en que modulo
   "sum", // nombre del metodo
   sum, // puntero a la implementacion C del metodo
   2 // cantidad de argumentos del metodo
   );
 
}

Para generar el makefile (solo hay que hacer esto una vez), se ejecuta el script extconf.rb:

ruby extconf.rb

Para construir la extension, se debe lanzar el siguiente comando:

make

Eso genera, entre otros archivos intermedios, extconf.so, el cual contiene la extension misma compilada a codigo nativo de la plataforma donde estan corriendo todo, para instalarla en el sistema, hay que correr (como root):

make install

Para usar la extension:

# test.rb
require 'rubygems'
require 'exttest'

Exttest.foo # el metodo foo definido en exttest.c!!
print Exttest.sum(4,9),"\n" # el metodo sum definido en exttest.c!!

Posteriormente, se pueden hacer cosas mas interesantes como definir clases, clases anidadas en modulos, metodos, etc...
Para la proxima voy a explicar como encapsular la extension como gem y distribuirla

links:

* http://onlamp.com/pub/a/onlamp/2004/11/18/extending_ruby.html: Fuente que inspiro este articulo y ejemplo practico de como wrappear la libreria GenX como libreria ruby GenX4r
* http://rhg.rubyforge.org/chapter04.html: Tutorial que muestra como definir clases y modulos
* http://ruby-doc.org/doxygen/1.8.4/group__ruby__interp.html: Documentacion completa de funciones C para definir extensiones de ruby incluyendo funciones de conversion de datos

En github solo se tarda 60 SEGUNDOS

Esta mañana, entre a la internet con la idea de migrar un proyecto que tenia en googlecode (con svn) a git (y el mas conocido repositorio gratuito en internet de git es github)
El hecho de tener que migrar commits de svn a git ademas de la registracion, setup del repo git y demas cosas me hacian imaginar q seria una experiencia de trabajo.
Pero me soprendi: no solo registrarse y crear el repositorio fueron tres simples clicks, sino que tambien hay literalmente un boton "migrar SVN a GIT" en el cual solo te pedia la url del servidor svn... tras la operatoria (que encima fue rapida), pude ver mis commits convertidos a git.
Asi que el que este entusiasmado con git, sabe que no solo puede registrarse facilmente a un repositorio git gratuito sino que puede tambien migrar cualquier repositorio de svn para no perder la valiosa informacion de los commits en la mudanza.

Enlaces:

GitHub:
http://github.com/

GoogleCode ( Aun asi esta bueno si quieren usar un repo svn y el issue-tracker les puede gustar :) ):
http://code.google.com/