Ejemplo Elixir. Gestión de login + OTP


En este ejemplo veremos un gestor de login parcialmente desarrollado.
Es un problema sencillo de gestión de estado…
sample2.png
El interfaz del actor estará compuesto por dos métodos rq_key y rq_login

Solución manual

defmodule LoginManager do

    def  start,  do: ...

    def  (rq_key   door),  do:  ...

    def  (rq_login  door, user_name, codded_pass),  do:  ...

end
En Elixir podemos modelarlo…
defmodule LoginManager do
    def start  do
        from_pid = self
        spawn(fn -> loging_manager_loop :w_rq_key, from_pid  end)
    end

    defp loging_manager_loop :w_rq_key, from_pid  do
        ...
    end


    defp loging_manager_loop :w_rq_login, key, from_pid  do
        ...
    end
end
La implementación del estado :w_rq_login…
    defp loging_manager_loop :w_rq_login, key, from_pid  do   1
        receive do
            {:rq_login, user_name, codded_pass}  ->           2
                          if login_rq_info_ok { user_name, key, codded_pass } do
                              send(from_pid, :login_ok)       3
                          else
                              loging_manager_loop  :w_rq_key, from_pid
                          end

            ignoring ->   IO.puts "Ignoring message #{inspect ignoring}"   4
                          loging_manager_loop  :w_rq_login, key, from_pid

            after 5000 -> IO.puts "exiting by timeout"                     5
        end
    end
1Punto de entrada para el estado w_rq_login
2El mensaje esperado es rq_login con nombre de usuario y la contraseña codificada
3Si es ok, respondemos con login_ok y terminamos
4Si recibimos cualquier otro mensaje, lo trazamos pero no cambiamos el estado
5Si no recibimos la petición de login, buy
El punto 4 es importante. Si recibimos un mensaje no esperado, en caso de que no lo recojamos, se quedará indefinidamente en la cola del proceso. Si esta cola creciese demasiado… peligro
El 5 también es interesante. Si nadie nos pide el login, nos vamos liberando la memoria y recursos.
Dejando de lado los dos últimos puntos, el resultado es muy elegante.
Y para probarlo…
Test
defmodule  LoginManagerTest do
  use ExUnit.Case

  test "request login" do
    rec = fn -> receive do  msg -> msg; after 1000 -> IO.puts "time out" end end
    d = LoginManager.start
    LoginManager.rq_key d
    key = rec.()
    coded_password = to_string :erlang.crc32(to_string(:erlang.crc32("joseluis"<>"1111"))<>key)
    LoginManager.rq_login  d, "joseluis", coded_password
    :login_ok = rec.()
  end

end
Aquí tenemos otros detalles poco elegantes. La recepción de la respueta es un poco incómoda. Estamos simulando una llamada síncrona con esteroides en un sistema asíncrono.
Estos patrones y dificultades son frecuentes. Para no gestionarlos manualmente siempre, debemos utilizar otp. No sólo evitaremos reescribir el mismo código, además utilizaremos un código de gran calidad, estabilidad y con patrones adecuados.
código completo solución manual
defmodule LoginManager do

    @moduledoc """
    This is a small Elixir example working with process as actor
    A partial implementation of a login manager.

    In order to login, it's necessary to call **rq_key** and
    compose the **rq_login** with the user name, the key and password
    using a non reversible (crc32) function
    """
    def start  do
        from_pid = self
        spawn(fn -> loging_manager_loop :w_rq_key, from_pid  end)
    end


    def  (rq_key   door),  do:   send(door, :rq_key)

    def  (rq_login  door, user_name, codded_pass),  do:   send(door, {:rq_login, user_name, codded_pass})



    defp loging_manager_loop :w_rq_key, from_pid  do
        :random.seed(:erlang.now)

        receive do
            :rq_key  ->   key = to_string(:random.uniform 100000)
                          send(from_pid, key)
                          loging_manager_loop  :w_rq_login, key, from_pid

            ignoring ->   IO.puts "Ignoring message #{inspect ignoring}"
                          loging_manager_loop  :w_rq_key, from_pid

            after 5000 -> IO.puts "exiting by timeout   defp loging_manager_loop :w_rq_key, from_pid  do"
        end
    end


    defp loging_manager_loop :w_rq_login, key, from_pid  do
        receive do
            {:rq_login, user_name, codded_pass}  ->
                          if login_rq_info_ok { user_name, key, codded_pass } do
                              send(from_pid, :login_ok)
                          else
                              loging_manager_loop  :w_rq_key, from_pid
                          end

            ignoring ->   IO.puts "Ignoring message #{inspect ignoring}"
                          loging_manager_loop  :w_rq_login, key, from_pid

            after 5000 -> IO.puts "exiting by timeout   defp loging_manager_loop :w_rq_login, key, from_pid  do"
        end
    end


    defp login_rq_info_ok  { _user_name, key, codded_pass }  do
        if(codded_pass == to_string :erlang.crc32(to_string(:erlang.crc32("joseluis"<>"1111"))<>key)) do
             :true
        else
             :false
        end
    end

end

Solución OTP

Utilizando exactor. Un conjunto de macros para hacer más cómodo y legible el trabajo conGenServer y otros elementos de OTP
defmodule LoginManager  do
  use ExActor.GenServer


    definit  do
        :random.seed(:erlang.now)
        initial_state(:w_rq_key)
    end


    defcall  rq_key,      state: :w_rq_key            do

        key = to_string(:random.uniform 100000)
        set_and_reply({:w_rq_login, key}, {:key, key})

    end

    defcall  (rq_login   user_name, codded_pass),    state: {:w_rq_login, key}   do

        if login_rq_info_ok { user_name, key, codded_pass }   do
            set_and_reply(:login_ok,  :login_ok)
        else
            set_and_reply(:rq_key,    :login_rejected)
        end

    end


    defp login_rq_info_ok  { _user_name, key, codded_pass }  do
        if(codded_pass == to_string :erlang.crc32(
               to_string(:erlang.crc32("joseluis"<>"1111"))<>key)) do
                :true
        else
                :false
        end
    end


end
El código se ha contraido tanto y es tan legible, que pongo directamente el programa completo.
Y esto no es todo, el programa de test, ahora también es mucho más sencillo, elegante y claro.
defmodule LoginManager2Test do
  use ExUnit.Case

    test "login ok" do
        {:ok, lm}   = LoginManager.start
        {:key, key} = LoginManager.rq_key lm
        codded_password = to_string :erlang.crc32(to_string(:erlang.crc32("joseluis"<>"1111"))<>key)
        :login_ok = LoginManager.rq_login lm, "joseluis", codded_password
    end

    test "login failed" do
        {:ok, lm}   = LoginManager.start
        {:key, key} = LoginManager.rq_key lm
        codded_password = to_string :erlang.crc32(to_string(:erlang.crc32("joseluis"<>"2222"))<>key)
        :login_rejected = LoginManager.rq_login lm, "joseluis", codded_password
    end
end
No todo es una maravilla con OTP. Algunos modelos sencillos manuales no son tan evidentes conOTP. Pero esto es sólo el principio.

Comentarios

Publicar un comentario

Entradas populares de este blog

Manifiesto ágil, un buen punto de partida

Principios del Manifiesto Ágil Nuestra mayor prioridad es satisfacer al cliente mediante la entrega temprana y continua de software con valor. Aceptamos que los requisitos cambien, incluso en etapas tardías del desarrollo. Los procesos Ágiles aprovechan el cambio para proporcionar ventaja competitiva al cliente. Entregamos software funcional frecuentemente, entre dos semanas y dos meses, con preferencia al periodo de tiempo más corto posible. Los responsables de negocio y los desarrolladores trabajamos juntos de forma cotidiana durante todo el proyecto. Los proyectos se desarrollan en torno a individuos motivados. Hay que darles el entorno y el apoyo que necesitan, y confiarles la ejecución del trabajo. El método más eficiente y efectivo de comunicar información al equipo de desarrollo y entre sus miembros es la conversación cara a cara. El software funcionando es la medida principal de progreso. Los procesos Ágiles promueven el desarrollo sostenible. Los promotores, desarr...
Leer más

No seas estúpido

Es un gran consejo, de no ser porque... "es un consejo ambiguo" Esto viola uno de los principios de educación infantil. Intentaré hacerlo mejor y para ello ayudará el señor Carlo María Cipolla Carlo María Cipolla fue un historiador económico que trabajó en Berkeley. Economía... No soy un entusiasta de la economía ni de la gran mayoría de los economistas. Pero reconozco que algunas ideas y desarrollos son concretos, prácticos e interesantes. Cipolla, partiendo de las transacciones entre individuos propone fijarnos en el beneficio y perjuicio para definir las siguientes categorías de individuos. En estas transacciones se analiza un individuo, contra uno o muchos más individuos (o la sociedad entera). Inteligente : Él sale beneficiado, y los demás también. Bandidos : Él sale beneficiado, y los demás perjudicados. Estúpido : Él sale perjudicado, y los demás también. Desgraciados : Él sale perjudicado, y los demás beneficiados Esto no es una definici...
Leer más

El principio

...y escribían en hojas de papel, el debe, el haber, el saldo, el stock, las compras, las ventas, las salidas, las entradas, cobros, pagos... y sumaban con lápiz y reglas, y multiplicaban, y dividían... y todo eso era mucho trabajo, y generaba muchos errores... ...y llegaron las máquinas automáticas que sumaban mecánicamente, con menos errores y más velocidad... y llegaron los ordenadores de válvulas, las cintas de almacenamiento y memorias de ferritas... y llegó el chip, la miniaturización, los "chips genéricos" que sabían manejar números rápidamente, memorias rápidas, almacenamientos masivos baratos...  y llegó internet, compartir el conocimiento, todo tipo de información accesible al instante. ¡Llegó la era de los ordenadores! Las empresas tuvieron un potencial de crecimiento enorme. Eliminaron todo el lastre de almacenamiento manual con boli y papel, anotaciones y cálculos manuales... Pero por el camino llegaron también problemas nuevos. Hojas de cálculo y bases de datos ...
Leer más