Recuperar commits "perdidos" en git

Cada tanto puede pasar que de checkout en checkout, nos encontramos con:

"¡oh no!, todos los commits que hice hoy no estan en la rama, incluso nisiquiera se donde estan"

Pareciera que todo el trabajo del dia quedo "perdido", pero no es asi, si se commiteo, esos commits estan en alguna parte... quiza no apuntados por ninguna referencia, pero estan.

Una de las maneras mas practicas de encontrarlo es usando el comando

git reflog

Que da por salida un registro de las operaciones que se hicieron, algo como esto:

8705300... HEAD@{0}: commit: aplicado metodo para desactivar los metodos privado
104683b... HEAD@{1}: commit: corregida restauracion de constantes
0a714ab... HEAD@{2}: commit: corregido error
f47b0e6... HEAD@{3}: commit: implementado metodo para activar y desactivar privi
7760e03... HEAD@{4}: commit: definido metodo permit, para definir muy facilmente
2936507... HEAD@{5}: commit: renombrado metodo para preguntar el permiso para ej
93757af... HEAD@{6}: commit: agregados enable y disable privileges con prints
4a2e9c3... HEAD@{7}: commit: agregado metodos para crear bloques unprivileged y
f19eb66... HEAD@{8}: commit: completado holder de manera que puede tener el codi
abc82d0... HEAD@{9}: commit: separado metodo create_holder
5185142... HEAD@{10}: commit (initial): primer commit

Incluye los "SHA1" de los commits hechos recientemente, de los cuales se pueden tomar los cambios y enviarlos al lugar correspondiente con git merge, crear branches o lo que sea necesario hacer.

Sandbox de codigo ruby

La semana pasada empece el desarrollo de una libreria de ruby que permita crear "sandbox" de codigo ruby

Un sandbox (traducido literalmente del ingles como "caja de arena") es un entorno "protegido" que permite ejecutar programas de una manera en la que no es posible que estos programas afecten a lo que esta "afuera" del sandbox (Por ej: ejecutar un programa de manera que no pueda tener acceso al sistema de archivos de la computadora en la que se esta ejecutando)

Para el caso particular de ruby, cuando se da, por ejemplo, el caso del desarrollo de una plataforma que ejecuta dinamicamente codigo enviado por muchos usuarios... es esperable que este codigo no pueda acceder al sistema de archivos o a la bases de datos de la aplicacion (el caso de una aplicacion Rails). En ese caso un "sandbox" que encierre al codigo en su ejecucion restringiria la ejecucion de codigo no deseado.

En lo que se ve a simple vista en la web, no hay mucho desarrollo al respecto... y lo que hay pareciera ser plugins algo mas especificos de rails como acts_as_runnable_code. Es por eso que comence el proyecto arena-ruby-sandbox, que define la posibilidad de ejecutar el codigo asi:

require "sandbox"

class X
 def foo(a)
  print "foo(#{a})\n"

  # estoy afuera del sandbox, por lo tanto puedo
  # hacer cosas "privilegiadas" como crear archivos
  # cosa que no puede hacerse desde adentro del sandbox
  File.open("foo.txt") do |f|
   f.write "foo(#{a})\n"
  end

  a+5
 end

 def foo_no_invocable
  print "foo_no_invocable\n"
 end
end

# instanciar el sandbox
s = Sandbox::Sandbox.new

x = X.new

s.serivice_provider = x
# indica que el metodo foo se puede ejecutar desde adentro del sandbox
s.permit :foo

print s.run("2+2") # => 4

print s.run("foo(2)") # => 7 (y escribe el archivo foo.txt con "foo(2)" )

print s.run("foo_no_invocable") # => NoMethodError (nunca se especifico que foo_no_invocable se podia invocar)

s.run("
 File.open('foo.txt') do |f|
  f.write \"foo\n\"
 end
")  # => NameError: uninitialized constant File
  # ( la clase File no existe adentro del sandbox
  # no se puede acceder al filesystem desde el sandbox

links

http://arena-ruby-sandbox.googlecode.com

Autocarga perversa

Textualmente, la rdoc del core de ruby, dice asi:

mod.const_missing(sym) => obj

Invoked when a reference is made to an undefined constant in mod. It is passed a symbol for the undefined constant, and returns a value to be used for that constant. The following code is a (very bad) example: if reference is made to an undefined constant, it attempts to load a file whose name is the lowercase version of the constant (thus class Fred is assumed to be in file fred.rb). If found, it returns the value of the loaded class. It therefore implements a perverse kind of autoload facility.

 def Object.const_missing(name)
   @looked_for ||= {}
   str_name = name.to_s
   raise "Class not found: #{name}" if @looked_for[str_name]
   @looked_for[str_name] = 1
   file = str_name.downcase
   require file
   klass = const_get(name)
   return klass if klass
   raise "Class not found: #{name}"
 end

Esa funcion puede utilizarse para implementar "alguna clase perversa de mecanismo de autocarga", para citar un ejemplo, rails lo utiliza como parte de su funcionamiento habitual para recargar las clases automaticamente sin necesidad de reiniciar el servidor ni ejecutar ningun comando explicito (¿rails = perversion?, esto me emociona).

links

http://ruby-doc.org/core/classes/Module.html#M001693

http://www.google.com.ar/search?q=%22It+therefore+implements+a+perverse+kind+of+autoload+facility%22

Web-Base Real Time Syntax Highlighting

Codepress es un editor de codigo fuente, que funciona 100% en javascript (del lado del browser) haciendolo muy simple de instalar y utilizar, por ejemplo, pueden editar el siguiente fragmento de codigo:

NOTA: puede que el highlighting no sea tan "automagico", pero seguro se refresca cada vez que se teclean las comillas dobles... despues cualquier cosa se investiga mas la herramienta...

NOTA2: Todavia no pude hacer andar bien el editor en el contexto del blog... pero al final estan todos los links a las paginas de prueba que muestran todo el potencial de la herramienta



Pagina de demo de codepress: http://bobdawg.org/codepress/
Descarga del paquete: http://sourceforge.net/projects/codepress/files/codepress/codepress-v.0.9.6/
Mi pagina de prueba: http://codepress-test.coolpage.biz/codepress/prueba.html

Tags remotos en git

Correccion: parametros de git push cambiados para que el envio de la ref sea mas propio

Otro elemento importante que aporta el versionador git, son los tags... No es muy intuitivo tampoco como hacer que los tags sea remotos, pero es parecido a como se hacen los branches e incluso mas simple (ya que no hay nada que trackear)


1) Enviar al repositorio central el ref de ese tag (en el ejemplo es el actual commit)

git push origin HEAD:refs/tags/nombre_del_tag

Este comando envio el "ref" local refs/tags/nombre_del_tag al servidor con el nombre refs/tags/nombre_del_tag
Cuando alguien haga pull del repositorio central recibira los tags y va a poder trabajar con ellos como si los hubieran creado con git tag en su repositorio.

Branches remotos en git

Git es un poderoso sistema de gestion de versiones, que entre otras cosas, esta pensado para gestionar branches ( cosa que por ej svn no tiene ), al ser git descentralizado y al ser de uso comun con varios repositorios para un mismo proyecto, surge la necesidad de crear ramas de manera distribuida tambien, algo que no es muy intuitivo.

1) Con git push se crea el branch en el repositorio remoto (en este caso origin), asi de simple

git push origin HEAD:refs/heads/nombre_del_branch

2) Despues tenemos que asegurarnos de tener actualizado el repositorio

git fetch origin

3) Verificamos que el branch remoto ha sido creado

git branch -r

4) Generar un branch local que "trackee" el branch remoto

git checkout --track -b nombre_del_branch origin/nombre_del_branch

Ese ultimo comando crea un branch local que "trackea" el branch que se creo antes en el repositorio remoto. Y con trackear implica que los cambios y commits del branch remoto vendran a este branch local al hacer git pull e iran de nuestro branch remoto al hacer git push.

Fuente: http://www.zorched.net/2008/04/14/start-a-new-branch-on-your-remote-git-repository/

Ruby RAII

RAII (Resource Acquisition Is Initialization) es una técnica aplicable en muchos lenguajes de programación como C++ y los lengujaes .net que sirve para asegurar que la liberación de un recurso siempre se llevara a cabo al cerrarse un bloque de código sin importar que evento ocurrise (retorno de una funcion, excepcion, etc...). Ruby por supuesto que cuenta con esta posibilidad a través del uso de métodos con bloques de código (palabra clave yield)

He aqui un ejemplo:

#
# La clase X tiene un metodo open para inicializar (open)
# Y uno para cerrar, seria una tragedia si el metodo open
# se invocara y no se invoque el close correspondiente al final
#
#
class X
 def open( argument1, argument2 )
  print "open with argument1=#{argument1} and argument2=#{argument2}\n"
 end

 def operation1
  print "running operation1\n"
 end

 def operation2
  print "running operation2\n"
 end

 def close
  print "closing\n"
 end
end


#
# Mejor usar RAII
#

class X
 def self.open( *args )
  x_instance = X.new
  x_instance.open( *args )
  begin
   yield(x_instance)
  ensure
   x_instance.close
  end
 end
end


#
# Y se usa asi
#
X.open( "arg1", "arg2" ) do |x|
 x.operation1
 x.operation2
end

Espero que os haya iluminado

NilClass horror

Un horror

# el nil class es la clase de la cual nil es instancia
class NilClass
  # todo metodo desconocido que es invocado sobre el nil
  def method_missing(method_obj,*args)
     method_obj.to_s
  end
end

print nil.koiiiewiiriieiw,"\n"

print @oooooooooooooooooooooo.blahhhhhhhhhhhhhhhhhhhhhhhhh,"\n"
print @ewewewwwewo.dakishimetakokoronokusumo,"\n"

# un horror
print $uqhwuiqwhrqrqwrkjwqhrjkqwhrqwkjrhqwrjkwqrhkqwrjqwrj.l,"\n"

Un horror

Comparacion de rangos

Es muy común al programar, encontrarse con la necesidad de verificar algún rango de algo:

# la manera "dificil"
if a > 3 and a < 9 then
   print "a esta entre 3 y 9\n"
end

Mejor asi, usando el operador ===

# la manera "canchera"
if (3..9) === a then
   print "a esta entre 3 y 9\n"
end

Como si esto fuera poco, el operador === tiene todos los usos que uno se pueda imaginar, como por ej, para verificar si un texto matchea una expresion regular:

# la manera "canchera"
if  /^ruby/ === txt then
   print "'#{txt}' tiene ruby al principio\n"
end

Y si se les da la gana, pueden usar este operador en sus propias clases (también obviamente definirlo o redefinirlo para la clase existente que quieran)

class X
   def ===(a)
      print a,"\n"
   end
end

Ruby hooking

Les traigo un truco que los asombrara... con una tenica de hooking aplicada al ruby para poder enganchar los metodos que quieran de cualquier objeto y controlar su ejecucion, asi como registrar llamados a ese metodo , filtrar cosas, etc.

Aca el module q lo hace posible:

hooking.rb

module Hook
 def hook( method_name, hook_name = nil, old_method_name = nil)
  
  obj = self
  
  # si no se le pasa el nombre de la funcion que controla el hook
  # arma un nombre de funcion
  hook_name ||= "#{method_name}_hook" 
  
  #lo mismo con el nombre de la variable de instancia
  # que almacena la referencia al metodo original
  old_method_name ||= "__old__#{method_name}"
  
  # almacenar el metodo original
  eval("@#{old_method_name} = self.method( method_name.to_sym)")
  
  # redefinir el metodo para que invoque el metodo de hook, pasandole
  # un bloque de codigo que ejecute el metodo original, entonces el metodo
  # de hook puede invocar al metodo original usando yield
  eval("
  def obj.#{method_name}(*x)
   self.#{hook_name}(@#{old_method_name},*x) do |*x|
    yield(*x) if block_given?
   end
  end
  ")
  
 end
end

class Object
 # includir el modulo de Hook en Object para que se pueda aplicar a todo Object
 include Hook
end

Y ahora un pequeño ejemplo de como podria usarse

main.rb

require "hooking"

class X

 def foo( num )
  print "metodo foo invocado con num = #{num}\n"
 end
 
 def bar 
  print "metodo bar invocado\n"
  [1,2,3].each do |x| yield(x) end
 end
 
end

x = X.new

x.hook(:foo)

def x.foo_hook( foo_original, num )
 print "foo invocado\n"
 
 # se invoca al metodo original, pero alterando los parametros
 foo_original.call( num+1)
 
 print "fin de foo\n"
end

x.hook :bar
def x.bar_hook(  bar_original )
 
 print "bar invocado\n"
 
 bar_original.call do |x|
                # tambien se puede alterar y controlar
                # el uso de yield del metodo
  yield(x+2)
 end
 
 print "fin de bar\n"
end


x.foo(3)
x.bar do |x|
 print x,"\n"
end

Me olvide de mostrarles el mirror rubik

Salio hace com 80 mil años, jaja, vean este video:



Y el video REVIEW:

Programacion ruby EN un celular :p

No pude evitar observar la palabra clave del ruby "def" (se usa para DEFinir metodos en ruby) en una de las teclas del celular, asi que imagine: esto esta pensado para programadores de ruby, en seguida me puse a pensar como seria programar EN un celular:

# para pner cmtrios ay q scrbrlos tods asi
# est mtodo c pue d usr cmo print
def abc(ghi)
print ghi,"\n"
#porq noay na tcla cn "end" en l celu?
end
abc "hla mndo!"
abc "cmo ests"

Aprendiendo git-svn en 5 minutos

Este finde estuve viendo las posibilidades que tiene git-svn, nunca use git pero me llamo mucho la atención el manejo que tiene de múltiples repositorios, cuya primera utilidad que le vi es poder trabajar "offline", es decir, sin acceso al repositorio central, y mantener la granularidad de los commits ya que se puede commitear al repositorio "local" cuantas veces se quiera hasta que en un momento se mandan todos los commits en un "push". En el caso de git-svn, se pueden visualizar y analizar en los logs del servidor SVN cada uno de esos commits como si hubiese mandando cada uno de ellos de manera "normal". git-svn también puede ser de agrado para los fanáticos de git cuando se vean forzados a trabajar con un repo svn y seguramente tiene un sin-fin de utilidades mas.

Actualizacion: Usuarios de svn pueden aprender git de una manera muy facil en Git - Svn Crash Course

Lo primero y principal para utilizar esta herramienta es instalarla, yo que uso fedora, me basto con:

yum install git-svn

Seguramente, para los usuarios de debian y afines sera suficiente (corrijanme si me equivoco):

apt-get install git-svn

Posteriormente, se aprende como utilizar la herramienta para clonar un repositorio SVN para los usuarios de git, o "checkautear" usando git, para los usuarios de svn:

git-svn clone $URL

Donde $URL es la url completa del servidor svn como "file:///usr/srv/svn/proyecto" o "http:///www.websvn.com/svn/proyecto", lo que hace el comando, es crear una copia local del repositorio SVN, al estilo de git, esto equivale al checkout de svn y por lo tanto solo debe hacerse la primera vez, obviamente es necesario tener acceso al repositorio para poder hacer esto

A partir de haber clonado el repositorio, ya se puede trabajar con el repositorio local, para los que sean usuarios de git es simple: es lo mismo que en git (guarda al final que no se pushean los cambios de la misma manera), y para los que no conocen el maravilloso mundo de git, también es sencillo, simplemente hay que ejecutar el siguiente comando con cada commit:

git commit archivo -m 'mensaje' 

El comando es igualito al de svn, pero tengan presente de que este comando "commitea" solo al repositorio local, el que se clono al principio, asi mismo NO requiere acceso al repositorio ni ninguna conexión con el, pueden hacer este commit todas las veces que hagan faltan sin necesidad de contactar al repositorio.

Cuando logran conexión con el repositorio o cuando lo crean conveniente, llega la hora de hacer el "push" (mandar todos los commits que se hicieron local al repositorio central), el comando el siguiente:

git-svn dcommit

Cuando ejecuten el comando, verán como git-svn manda cada commit que se efecto localmente desde la que se clono el repo o se hizo el ultimo dcommit, y lo mas importante, lo que da todo el sentido a esto: a cada commit que efectuaste con "git commit", le corresponde UN commit de svn que puede analizarse y verse en los logs del servidor svn por cualquier otro usuario y con las herramientas svn clásicas.

Bueno, esto fue git-svn para Fedora 32 y espero que les haya gustado. Chau!!!

Try ruby (in the NilClass Blog)

Cableando algunos iframe por ahi logre incorporar el interprete de ruby que anuncie en el post anterior directamente inscrustado en ell blog, para ahorrarles ir a la otra pagina ;), prueben el ruby!!!

Try ruby! (in your browser)

Actualizacion: la nueva direccion de tryruby es http://tryruby.org/

Buscando algun applet o algo asi para acercarles el ruby en este blog para que puedan palpar la magia de ruby sin nececidad de que se instalen nada, me encontre con http://tryruby.org/, una pagina muy curiosa que te ofrece un tutorial de ruby con interprete incluido en la pagina!, es decir, podes aprender ruby como Yukihiro manda sin necesidad de bajarte ni instalar nada. En lo proximo.

FreeMind, la exprimidora de jugo mental

El Jueves que pasado, tratando de hacer algo bueno para el rsif, no se me ocurria que cosa buena programar, ni ninguna parte del soft que diseñar, ni siquiera ideas que documentar. Ocasion ideal para utilizar la aplicacion que les voy a comentar: se trata del Freemind. El freemind es un programa que te permite hacer brainstorming, es decir, volcar a algun lugar las ideas flotando en la intangibilidad de la conciencia antes de que migren a olvidolandia, tambien permite multiplicar facilmente las ideas de varios participantes en un grupo de trabajo. Para poder hacer eso, te permite crear "mapas" que son arboles (como el que se ve en la imagen) o una "mariposa" lleno de ideas que descargas directo de tu atormetado cerebro (o varios cerebros si es un grupo) por intermedio del teclado y mouse; los nodos del arbol que podes ir armando, contienen simplemente cualquier texto que se quiera poner, a los que se le pueden añadir cualquier cantidad de iconos. Al final, se obtendra como resultado un map "mariposa" cuyas alas estan hechas de las ideas que se crearon/escribieron y cuya utilidad es obvia.

Sitio oficial de freemind: http://freemind.sourceforge.net

El pentaminx es una cosa de locos

Es un rubik pero en version dodecaedro diabolico (con pentagrama en cada cara), por si el V-cube 6 del post anterior te parecia para bebes, podes disfrutar del reto que ofrece el Pentaminx, el cual consta de 12 hyper-enfermizas caras dividas en aproximadamente 100 partes de las cuales 20 de ellas son secciones de las puntas de la estrella central y una es un pentagono interior. El mounstruo esta hecho de un total de 975 piezas, y se dice que el record mundial de resolucion mas rapida fue de 75 horas

De finales a RSIF

Complete la agonizante fase de examenes, sin entrar en detalles como me fue, solo voy a decir que lo unico que me interesa es volver al proyecto de rsif, la vuelta a rsif va a ser con un nuevo planteo el cual van a poder conocer leyendo el blog de rsif e implicara cambios muy importantes acerca de la metodologia de desarrollo apuntando a mejorar el uso, la utilidad, la flexibilidad y lograr objetivos practicos con el framework.

El proyecto hara ignicion en un mega-post tras algunos dias de meditacion extrema, ruby testing y filosofia ruby

V-Cube 6x6x6 Resuelto en 3 minutos y 28 segundos

Este chabon resuelve el V-Cube de 6x6x6 en 3 minutos y 28 segundos, por si no lo sabían, el de 6x6x6 existe materialmente e incluso hay algunos como los del video que resuelven asi:

openVPN temporal rapida y practica en linux

Con estos comandos, pueden crear una vpn de manera muy rápida y sencilla con openvpn, y sin necesidad de "configuración", si por alguna urgencia necesitan vpn...

En el server:

openvpn --proto tcp-server --lport 9000 --dev tun0 --ifconfig 10.4.0.1 10.4.0.2

En el client

openvpn --proto tcp-client --rport 9000 --remote DIRECCIONIPREMOTA --dev tun0 --ifconfig 10.4.0.2 10.4.0.1

NOTA: asegúrense de que no colisionen las ips del ifconfig y que los puertos sean accesibles (en el ejemplo el 9000),

NOTA: pueden no especificar el proto, y utiliza el protoclo por defecto UDP

Forma elegante de expresar el codigo ascii de un caracter especifico

Simplemente hay que utilizar el operando "?", anteponiendo lo al carácter del cual se quiere obtener el código ASCII, en el siguiente ejemplo se usa "?A" para obtener el código ASCII de la letra A mayúscula

# el abecedario en mayúsculas
# la funcion chr convierte un numero al carácter que representa en ASCII
print (0..25).map{|x| (?A+x).chr}.join(" ")

Ampliar la funcionalidad de una clase existente

Hola, estamos viendo el ruby para PC, y hoy les voy a pasar un truco para agregarle funcionalidad a una clase ya existente en el lenguaje (también otra que se haya definido de la manera que sea, puede ser extendida )

Supongamos que no nos gusta que el metodo para convertir a entero de la clase String, se llame to_i, y nos parece mejor idea que se llame to_integer

class String
   def to_integer
      to_i
   end
end

print "99".to_integer + 1, "\n"

Lo que hicimos fue definir de manera parcial la clase String, esto es, definirle los métodos que queramos a String, obviamente manteniendo también los métodos originales de la clase String




Bueno, esto fue ruby para PC, y espero que les haya gustado, chau

Usa yield, por que si no lo usas se oxida

Sin duda, yield es un elemento muy poderoso de estos lenguajes de programación "modernos", en definitiva, lo que yield hace es invocar el bloque de código que se le paso por parámetro a un método especifico. Un ejemplo

def foo(x)
   if x < 3
      yield
   end
end

foo(2) { print "hola mundo" }

Con la sola definición de yield no es sencillo darse cuenta rápidamente de como podría aplicarse, pero para que se den una idea, todos los métodos del array que reciben bloques estan implementados usando yield, estos son (entre otros), each, inject, select, find, etc..., también métodos como synchronize del mutex usan yield con propósitos de RAII y con un sin fin de aplicaciones. Aca otro ejemplo:

# compone cualquier funcion dos veces, toma como inicio el parámetro
def compdouble(x)
  yield(yield(x))
end

# devuelve x*x*x*x = 81 (composicion doble de x*x)
print compdouble(3){ |x| x*x }, "\n"

también puede servir para pasar expresiones como parámetros, que solo seran evaluadas si se necesitan, la siguiente idea se aplico en el logger de rsif

# invocamos logger.info con parametro normal, entonces el
# interprete siempre evalúa la expresión
# para pasarle el parámetro a logger.info,
#sin importar si logger info vaya a loguear o no
# aveces evaluar determinadas expresiones conlleva
# a invocar metodos, accesar a bases de datos,
# hacer calculos, etc..

logger.info Locale.hello_world

# Es mejor si en lugar de pasarle el paremetro
# normalmente, se lo pasemos en un bloque
# entonces el bloque solo sera invocado
# si el parametro necesita ser evaluado, es decir
# cuando el metodo decida que va a loguearlo, definitivamente

logger.info { Locale.hello_world } # las llaves hacen que se pase el bloque de código

# pseudo-codigo resumido de logger.info:

def logger.info( x = nil )
  if loguear
     if block_given?
         print yield,"\n"
     else
         print x,"\n"
     end
  end
end

Otro ejemplo es la implementación de visitor pattern usando ruby, con yield es muy cómoda de implementar y también de usar (el link que les pase hace la comparativa entre la implementación de lo mismo en varios lenguajes)

Espero que les haya sido de utilidad, hasta el próximo post

¿Porque pasa? Grave vulnerabilidad de ejecucion de codigo en el kernel 2.6.28 (y otros)

Asi como le escucharon, salio un nueva vulnerabilidad del kernel 2.6.28 con impacto de ejecución remota de código ( o Denial of service, segun el caso ), aca una copia de la nota original, de watchmouse:

------------------------------------------------------------------------------------------------------------------------

The Linux Kernel is prone to a remote buffer-overflow vulnerability because the software fails to perform adequate boundary checks on user-supplied data.

An attacker can exploit this issue to execute arbitrary code with kernel-level privileges. Successfully exploiting this issue will result in the complete compromise of affected computers. Failed exploit attempts will result in a denial-of-service condition.

The issue affects Linux Kernel 2.6.28; other versions may also be vulnerable.
------------------------------------------------------------------------------------------------------------------------


Que bueno que en el software libre estas cosas se corrigen rapido, lo mas que podemos hacer es actualizar el kernel y ya hay una versión patcheada, o parchearlos nosotros mismos si esta a nuestro alcance

La nota original de la pueden leer aca

En securityfocus pueden ver mas información acerca de la vulnerabilidad, las versiones afectadas del kernel, etc...

net-security también publico una nota

Comenzo el proyecto RSIF (hace un rato)

Buscando una excusa interesante para hacer un proyecto en ruby, me encontre con que no habia ninguna herramienta de sql injection automatizado (hecha por mi). De ahi que comenze con el proyecto Rsif. Rsif significa Rsif Sql Injection Framework, y es lo que dice (o mejor dicho, quiere ser :p ), y lo mas orientado posible a la participacion de cualquiera.

Si quieren mas informacion, pasense por el blog de rsif, que es el que motivo este articulo, en primer lugar

El Ruby brilla y refleja: local_variables y demas

Para los que no saben, en el scope de cada metodo en ruby nacen las variables locales (y mueren si no "trascienden", pero eso es asunto de otro post), ruby tiene algunas variables predefinidas en toda funcion que pueden hacer cosas interesantes, una de ellas es "local_variables", la cual es un array de todas las variables locales definidas hasta el momento, se puede usar de la siguiente forma:

a = 1
b = 2
c = 3

local_variables.each do |vn|
   print "#{vn}=#{eval(vn)}\n"
end

eso devuelve por la salida:

a=1
b=2
c=3

Las utilidades que pueden darle a esto les dejo a su imaginacion

Todo mal, Diego Gomez es un clone, frakin cylon machine

La verdad que no me esperaba una tragedia como esta, al parecer, mi amigo y compañero de trabajo tiene sangre de mentira en las venas, una fuente ATX en lugar de corazón y un destello rojo en vez de alma :(, esto lo descubri buscando el blog de Dieguito por la web para encontrarme con que se vislumbran dos copias de este modelo de cylon:

* Diego Gomez "phantom", tiene un blog, es aficionado a la tecnología, la web, el software libre y el humor (usa debian)

* Diego Gomez "deck", tiene un blog, es aficionado a la tecnología, la web, el software libre y el humor (seguro usa debian también)

Para el que este desinformado acerca del tema de los cylon, solo les digo que fueron construidos por el hombre, se rebelaron, y se ven como y creen que son humanos :(

Factorial super compacto en ruby

Posiblemente algunos conoceran la clasica implementacion del factorial en ruby, para los que no, la posteo aca:

def factorial(n)
 if n > 1
  # casos mayor que 1, se usa la formula recursiva
  # n! = n*(n-1)!

  n * factorial(n-1)
 else
  # casos 0 y 1, devuelve 1
  1
 end
end

Les presento una forma mas compacta de expresar el factorial

def factorial(n)
  # el metodo inject del rango 2..n multiplica
  # todos los elementos del conjunto tal como indica
  # el bloque de codigo que se le esta pasando
  (2..n).inject{|x,y| x*y}
end

A donde sea que vayan, lleven un interprete de ruby con ustedes

Patch para VMware Server 1.0.8 en linux kernel 2.6.27

Termine una versión del patch para vmware bajo linux para kernels nuevos ( testeado en un fedora con kernel 2.6.27.9 ), básicamente este patch corrigen los problemas descriptos en este post

A las correcciones descriptas en el articulo anteriormente mencionado, se le suma la corrección de la deferencia de puntero nulo, la que producía el colapso del kernel (el de la maquina host :S ) y escupía este backtrace:

[<f99e76a1>] HostIF_SetFastClockRate+0x8d/0x148 [vmmon]
[<f99efd65>] Vmx86_SetHostClockRate+0xad/0xd5 [vmmon]
[<f99e5a87>] LinuxDriver_Ioctl+0x4c6/0xdcd [vmmon]
[<c0118694>] kmap_atomic_prot+0x102/0x137
[<c0395846>] _spin_unlock+0x5/0x1c
[<c017bd62>] mnt_drop_write+0x64/0xdd
[<c01f0680>] rb_insert_color+0x4c/0xad
[<c013260a>] enqueue_hrtimer+0xc9/0xd4
[<c0132ba5>] hrtimer_start+0xf9/0x129
[<c011a13c>] hrtick_start_fair+0xf7/0x123
[<c0129e78>] group_send_sig_info+0x12/0x56
[<c0129eed>] kill_pid_info+0x31/0x54
[<c012a44e>] sys_kill+0x73/0x13e
[<c0172b53...


Pasaba que en el archivo linux/hostif.c, en la funcion HostIF_SetFastClockRate, aproximadamente por la linea 3480, habia algo asi:

res = filp->f_op->ioctl(filp->f_dentry->d_inode, filp, RTC_PIE_ON, 0);
if (!cap) {
 cap_lower(current->cap_effective, CAP_SYS_RESOURCE);
}

Y aparentemente, en ocasiones, filp->f_op->ioctl (que es un puntero a una función, para los mas desprevenidos), tenia el valor de 0, es decir un puntero a nada, para solventar esto, simplemente cambie ese bloque de codigo por esto:

// mejor verificamos si ioctl es un puntero nulo antes
// de deferenciarlo como puntero funcion
if (filp->f_op->ioctl == 0) {
// si el puntero es nulo, hacemos de cuenta que
// la función devolvió status de error
res = -1;
} else {
// ojo, en esta seccion de esta deferencia ioctl como puntero
// que bueno que ya se verifico
res = filp->f_op->ioctl(filp->f_dentry->d_inode, filp, RTC_PIE_ON, 0);
if (!cap) {
   cap_lower(current->cap_effective, CAP_SYS_RESOURCE);
}
}

Y con eso se chequeo el puntero antes de deferenciarlo

Uh, casi me olvidaba, aca esta el patch, tengan en cuenta que es para la version 1.0.8-126538 (no se descarata que funcione en otras versiones de vmware, pero yo solo lo probe con esa), por favor, si lo prueban comenten a este articulo que tal les fue, si hubo problemas, para que version de vmware y linux (kernel) instalaron el patch, etc...

Feliz año nuevo

Feliz año 2009 para todos, y que todos sus proyectos se cumplan y sean de software libre.