Scala Future con Ejemplos, continuación

En la entrada anterior, “Scala Future con Ejemplos”, realicé una descripción de cómo utilizar la entidad Future en Scala con ejemplos. En la presente entrada, “Scala Future con Ejemplos, continuación”, realizaré una ampliación de Future y, además, describiré ejemplos de utilización de Future con Actores.

El modelo de actores, segun wikepedia, es un modelo matemático de computación simultánea que trata a los actores como los primitivos universales de la computación concurrete. La implementación que utilizaremos es la que proporciona Akka y voy a suponer que el lector tiene unos conocimientos mínimos del modelo de actores y de Akka. La definición de dependencia de la librería Akka en sbt es la siguiente:

libraryDependencies += "com.typesafe.akka" %% "akka-actor" % akkaVersion,

Para la realización de los siguientes ejemplos, es necesario definir un actor con una mínima funcionalidad. La funcionalidad es la siguiente: si el actor recibe un mensaje de tipo String (msg), el actor responde con la concatenación del contenido de msg con el texto “Recibido en Actor”; si el actor recibe cualquier otro mensaje, el actor responde con el mensaje “Hola Mundo.” La implementación del actor es la siguiente:

import akka.actor.{Actor, Props}
import scala.concurrent.Future
object ActorEjemplo {
  def props() = Props(new ActorEjemplo())
}
class ActorEjemplo extends Actor {
  import context.dispatcher
  def receive = {
    case msg:String =>{
      val respuesta = msg + " Recibido en Actor"
      println(respuesta)
      sender() ! respuesta
    }
    case _ => {
      val respuesta = "Hola Mundo"
      println(respuesta)
      sender() ! respuesta
    }
  }
}

La lista de ejemplos que se muestran son los siguientes:

  • Ejemplo 1: ejemplo de Futures con tratamiento funcional
  • Ejemplo 2: ejemplo de Futures con tratamiento funcional
  • Ejemplo 3: ejemplo de Futures con tratamiento funcional.
  • Ejemplo 4: ejecución de un Actor con tiempo de espera.
  • Ejemplo 5: ejecución de un Actor sin tiempo de espera.
  • Ejemplo 6: composición de Futures.
  • Ejemplo 7: composición de Furures con for comprehension.
  • Ejemplo 8: conversión de List[Future[A]] -> Future[List[A]]
  • Ejemplo 9: conversión de Future[List[A]] -> List[Future[A]]
  • Ejemplo 10: morfismos con Future, función fold.
  • Ejemplo 11: morfismos con Future, función reduce
  • Ejemplo 12: el primero que termine, se ejecuta; función firstCompletedOf

Ejemplo 1: ejemplo de Futures con tratamiento funcional

Sea un Future future1 cuyo resultado sea el texto “Hello world!”; sea el Future future2 cuyo resultado es el valor entero 3; y, por último, sea el Future future3 que define una secuencia de operaciones con futuro1 y future2 para realizar un cálculo numérico a partir de la ejecución secuencial de future1 y future2.

El snippet del código con las ejecución de las tres futuros  la solución es la siguiente:

def ejemplo(): Unit = {
  val future1 = Future {
    "Hello world!"
  }
  val future2 = Future.successful(3)
  val future3 = future1 map { elemf1 =>
    future2 map { elemf2 =>
      elemf1.length * elemf2
    }
  }
  future3 onComplete {
    case Success(resultado) => println(s"resultado ejemplo3=${resultado}")
    case Failure(error) => println(s"error ejemplo3=${error}")
  }
}

La salida por consola de la ejecución del código anterior es la siguiente:

resultado ejemplo3=Success(36)

Ejemplo 2: ejemplo de Futures con tratamiento funcional

El siguiente ejemplo es el mismo que el caso anterior pero empleando la función foreach.

def ejemplo(): Unit = {
  val future1 = Future {
    "Hello world!"
  }
  val future2 = Future.successful(3)
  val future3 = future1 flatMap { elemf1 =>
    future2 map { elemf2 =>
      elemf1.length * elemf2
    }
  }
  future3 foreach { elem => println(s"Resultado ejemplo4=${elem}") }
}

La salida por consola de la ejecución del código anterior es la siguiente:

Resultado ejemplo4=36

Ejemplo 3: ejemplo de Futures con tratamiento funcional

Sean tres Futures cuyo resultado individual son tres operaciones matemáticas simples y, el último Future, define un filtro. El resultado será la multiplicación del segundo por el tercero.

El snippet del código con la solución es la siguiente:

def ejemplo5(): Unit = {
  val resultado = for {
    a <- Future(10 / 2)
    b <- Future(a + 1)
    c <- Future(a - 1)
    if c > 3
  } yield {
    b * c
  }
  resultado foreach { elem => println(s"Resultado ejemplo5=${elem}") }
}

La salida por consola de la ejecución del código anterior es la siguiente:

Resultado ejemplo5=24

Ejemplo 4: ejecución de un Actor con tiempo de espera

El ejemplo siguiente realizará la creación de un actor, envío de un mensaje y el tratamiento de la respuesta del actor con un tiempo de espera; para finalizar, se realizará la eliminación del actor del ejemplo enviándole el mensaje “PoisonPill”. La definición del actor es la definida al principio de la entrada y el sistema de actores es el identificado con el identificador “Ejem”.

El código del ejemplo es el siguiente:

import scala.concurrent._
import ExecutionContext.Implicits.global
implicit val system = ActorSystem("Ejem")
implicit val timeout = Timeout(2 seconds)
def ejemplo1(): Unit = {
  val actorEjemplo1 = system.actorOf(ActorEjemplo.props(), "ActorEjemplo1")
  val future: Future[Any] = actorEjemplo1 ? "Mensaje"
  val result: String = Await.result(future, timeout.duration).asInstanceOf[String]
  println(s"\nresultado ejemplo1=${result}")
  actorEjemplo1 ! PoisonPill
}

La salida por consola de la ejecución del código anterior es la siguiente:

Mensaje Recibido en Actor
resultado ejemplo1=Mensaje Recibido en Actor

La creación del actor se realiza con la función actorOf del sistema de actores identificado  como system; el envío de un mensaje a un actor se utiliza la función “?”; y, su resultado, es gestionado por el componente Await el cual opera con la respuesta de tipos Future que retorna el actor.

Ejemplo 5: ejecución de un Actor sin tiempo de espera

El siguiente ejemplo es idéntico que el anterior pero se espera la respuesta del actor de tipo Future sin tiempo de espera. La lógica es la misma que el ejemplo anterior pero se emplea la función onComplete para gestionar el resultado de ejecución. El código del ejemplo es el siguiente:

def ejemplo2(): Unit = {
  val actorEjemplo2 = system.actorOf(ActorEjemplo.props(), "ActorEjemplo2")
  // La función mapTo retorna un nuevo Future con la respuesta si es Success; en otro caso, ClassCastException.
  val future: Future[String] = ask(actorEjemplo2, "mensaje").mapTo[String]
  future onComplete {
    case Success(resultado) => println(s"\nresultado ejemplo2=${resultado}\n")
    case Failure(error) => println(s"\nerror ejemplo2=${error}\n")
  }
  actorEjemplo2 ! PoisonPill
}

Ejemplo 6: composición de Futures.

Supongamos que necesitamos ejecutar dos futuros y, su resultado, es la entrada de un tercer futuro. Una posible solución con un tiempo de espera determinado es la siguiente:

def ejemplo6(): Unit = {
  val actorEjemplo6_1 = system.actorOf(ActorEjemplo.props(), "ActorEjemplo6-1")
  val actorEjemplo6_2 = system.actorOf(ActorEjemplo.props(), "ActorEjemplo6-2")
  val actorEjemplo6_3 = system.actorOf(ActorEjemplo.props(), "ActorEjemplo6-3")

  val future1 = actorEjemplo6_1 ask ("Mensaje a Actor6_1")
  val future2 = actorEjemplo6_2 ask ("Mensaje a Actor6_2")

  val respuestaFuture1 = Await.result(future1, 3 seconds).asInstanceOf[String]
  val respuestaFuture2 = Await.result(future2, 3 seconds).asInstanceOf[String]
  val future3 = actorEjemplo6_3 ask ("##" + respuestaFuture1 + "&" + respuestaFuture2 + "##")
  val respuestaFuture3 = Await.result(future3, 3 seconds).asInstanceOf[String]
  println(s"resultado ejemplo6=${respuestaFuture3}")
}

La salida por consola de la ejecución del código anterior es la siguiente:

Mensaje a Actor6_1 Recibido en Actor
Mensaje a Actor6_2 Recibido en Actor
##Mensaje a Actor6_1 Recibido en Actor&Mensaje a Actor6_2 Recibido en Actor## Recibido en Actor
resultado ejemplo6=##Mensaje a Actor6_1 Recibido en Actor&Mensaje a Actor6_2 Recibido en Actor## Recibido en Actor

Ejemplo 7: composición de Furures con for comprehension

El siguiente ejemplo es el mismo que el caso anterior pero se emplea for comprehensión.

def ejemplo7(): Unit = {
  val actorEjemplo7_1 = system.actorOf(ActorEjemplo.props(), "ActorEjemplo7-1")
  val actorEjemplo7_2 = system.actorOf(ActorEjemplo.props(), "ActorEjemplo7-2")
  val actorEjemplo7_3 = system.actorOf(ActorEjemplo.props(), "ActorEjemplo7-3")
  val future1 = actorEjemplo7_1 ask ("Mensaje a Actor7_1")
  val future2 = actorEjemplo7_2 ask ("Mensaje a Actor7_2")
  val future3 = for {
    f1 <- future1.mapTo[String]
    f2 <- future2.mapTo[String]
    c <- ask(actorEjemplo7_3, "##" + f1 + "&" + f2 + "##").mapTo[String]
  } yield {
    c
  }
  future3 foreach { resultado => println(s"Resultado ejemplo7=${resultado}") }
}

La salida por consola de la ejecución del código anterior es la siguiente:

Mensaje a Actor7_2 Recibido en Actor
Mensaje a Actor7_1 Recibido en Actor
##Mensaje a Actor7_1 Recibido en Actor&Mensaje a Actor7_2 Recibido en Actor## Recibido en Actor
Resultado ejemplo7=##Mensaje a Actor7_1 Recibido en Actor&Mensaje a Actor7_2 Recibido en Actor## Recibido en Actor

Ejemplo 8: conversión de List[Future[A]] -> Future[List[A]]

Supongamos que tenemos una lista de operaciones Futuras del mismo tipo, en nuestro caso, Futuros cuya respuesta son números enteros; y, su procesamiento, puede ser transformado un un único Future. La solución consiste en emplear la función sequence la cual es la encargada de transformar muchos Future en uno único. Así, la solución se define de la siguiente forma:

def ejemplo8(): Unit = {
  val listaFutures: List[Future[Int]] = List(Future(1), Future(3), Future(5), Future(7))
  // Convertimos un List[Future[Int]] en Future[List[Int]] para trabajar con el Future.
  // Así, podemos trabajar con la List[Int]
  val futureList: Future[List[Int]] = Future.sequence(listaFutures)
  println(s"futureList=${futureList}")
  val suma: Future[Int] = futureList.map(_.sum)
  suma foreach{elem => println(s"Resultado ejemplo8=${suma}")}
}

La salida por consola de la ejecución del código anterior es la siguiente:

Resultado ejemplo8=Success(16)

Ejemplo 9: conversión de Future[List[A]] -> List[Future[A]]

Supongamos que tenemos un único Future y una lista de datos de un determinado tipo  que procesar y, su procesamiento, puede ser ejecutado por N Futuros. La solución consiste en emplear la función traverse. El código del ejemplo es el siguiente:

def ejemplo9(): Unit = {
  // Convertimos un Future[List[Int]] en List[Future[Int]] para trabajar con el Future.
  val futureList1 = Future.traverse((1 to 10).toList)(x => Future(x * 2 - 1))
  val resultadoFutureList1 = futureList1.map(_.sum)
  resultadoFutureList1 foreach {elem => println(s"Resultado1 de ejemplo9=${elem}")}
  val futureList2 = Future.traverse(List(1,3,5))(x => Future(x * 2 - 1))
  val resultadoFutureList2 = futureList2.map(_.sum)
  resultadoFutureList2 foreach {elem => println(s"Resultado2 de ejemplo9=${elem}")}
}

La salida por consola de la ejecución del código anterior es la siguiente:

Resultado2 de ejemplo9=15
Resultado1 de ejemplo9=100

Ejemplo 10: morfismos con Future, función fold

Supongamos que tenemos un ADT de tipo lista de futuros no bloqueantes y queremos realizar un morfismo sobre dicho ADT; el mecanismos para realizarlo, es utilizar la función fold. El siguiente snippet muestra un ejemplo representativo:

def ejemplo10(): Unit = {
  val listaFutures: List[Future[Int]] = List(Future(1), Future(3), Future(5), Future(7))
  val sumaListaFutures = Future.fold(listaFutures)(0)(_+_)
  sumaListaFutures onComplete{
    case Success(resultado) => println(s"Resultado ejemplo10=${resultado}")
    case Failure(error) => println(s"Error ejemplo10=${error}")
  }
}

Ejemplo 11: morfismos con Future, función reduce

La función reduce es como la función fold pero sin valor inicial.

def ejemplo11(): Unit = {
  val listaFutures: List[Future[Int]] = List(Future(1), Future(3), Future(5), Future(7))
  val futureSum: Future[Int] = Future.reduce(listaFutures)(_ + _)
  futureSum foreach { elem => println(s"Resultado ejemplo11=${futureSum}") }
}

La salida por consola de la ejecución del código anterior es la siguiente:

Resultado ejemplo11=Success(16)

Ejemplo 12: el primero que termine, se ejecuta; función firstCompletedOf

Supongamos que tenemos una lista de futuros en un ADT de tipo lista; y, a nivel de negocio, solo nos interesa el resultado del primer future que termina; en estos casos,  se emplea la función firstCompletedOf. El siguiente ejemplo muestra un ejemplo representativo.

def ejemplo12(): Unit = {
  val listaFutures: List[Future[Int]] = List(Future(1), Future(3), Future(5), Future(7))
  val futureFirst: Future[Int] = Future.firstCompletedOf(listaFutures)
  futureFirst foreach { elem => println(s"Resultado ejemplo12=${futureFirst} elem=${elem}") }
}

Una de las posibles salidas por consola de la ejecución del código anterior es la siguiente:

Resultado ejemplo12=Success(3) elem=3

Estos son los ejemplos que presento, si al lector interesado se le ocurre plantear otro ejemplo, o bien, plantear cualquier otra alternativa, estaré encantado de compartirlo.

Scala: Future con Ejemplos

En todo proyecto o aplicación informática es habitual realizar alguna operación asíncrona, es decir, ejecutar una operación en donde se lanza un mensaje de una operación sin quedarte bloqueado a la espera de su resultado. En la entrada de hoy, “Scala Future con ejemplos”, voy a presentar unos ejemplos de utilización de Future desde un punto de vista practico.

Sin ser exhaustivo, podemos definir Future como aquel objeto que contiene un valor el cual estará disponible en algún instante.

La estructura de los ejemplos es incremental en dificultad y los ejemplos que presento son ejemplos que en nuevas versiones del lenguaje pueden presentar diferencias. Los ejemplos son los siguientes:

  1. Ejemplo 1 básico desde consola
  2. Ejemplo 2 básico desde consola.
  3. Ejemplo 3 básico desde consola.
  4. Ejemplo 4: Future y tratamiento de errores con recover.
  5. Ejemplo 5: Future y tratamiento de errores con recoverWith.
  6. Ejemplo 6: Future y ejecución paralela con función fallbackTo.
  7. Ejemplo 7: Future y ejecución paralela con función zip.
  8. Ejemplo 8: Future y ejecución paralela con for comprehension.
  9. Ejemplo 9: Tratamiento de tareas Future para aquella que acabe primero.

Ejemplo 1 básico desde consola

El ejemplo más básico es ejecutar un código en la consola Scala; para ello, arrancamos la consola; insertamos el comando “:paste” y, posteriormente, copiamos el siguiente snippet de código finalizando con Ctrl- D.

El ejemplo define un Future en el cual se lanza una excepción; una vez recibida el resultado, se escribe por la salida estándar.

import scala.concurrent._
import ExecutionContext.Implicits.global
val futureFail = Future { throw new Exception("Error!") }
futureFail.foreach( value => println("->" + value) )

La salida de la ejecución es la siguiente:

import scala.concurrent._
import ExecutionContext.Implicits.global
futureFail: scala.concurrent.Future[Nothing] = Future(Failure(java.lang.Exception: Error!))

Ejemplo 2 básico desde consola

Continuamos con la consola y, en este segundo ejemplo, el snippet del código se centra
en la gestión del resultado del Future con la función onComplete y los objetos Success
y Failure. El código es el siguiente:

import scala.util._
import scala.concurrent._
import ExecutionContext.Implicits.global
val futureFail = Future {
  throw new Exception("Error!")
}
futureFail.onComplete {
  case Success(value) => println("Success:" + value)
  case Failure(e) => println("Respuesta Failure:" + e)
}

La salida de la ejecución es la siguiente:

import scala.util._
import scala.concurrent._
import ExecutionContext.Implicits.global
futureFail: scala.concurrent.Future[Nothing] = Future(<not completed>)
Respuesta Failure:java.lang.Exception: Error!

Ejemplo 3 básico desde consola

La funcionalidad de un Future puede ser una función completa y, en su definición funcional, podemos utilizar funciones, o bien, definir Future en funciones.

En el presente snippet, se definen dos funciones que ejecutan Future: getEvent y getTraffic; además, se define una secuencia de ejecución de Future empleando las funciones anteriores: futureStep1 y futureStep2; el resultado de la ejecución de la secuencia, lo realiza futureStep2 el cual controla el resultado empleando objetos Success y Failure.

import scala.util._
import scala.concurrent._
import ExecutionContext.Implicits.global
def getEvent(parametro: String): Future[String] = {
  val resultadoGetEvent = Future{
    val resultado = "getEvent: " + parametro
    resultado
  }
  resultadoGetEvent
}
def getTraffic(parametro: String): Future[String] = {
  val resultadoGetTraffic = Future {
    val resultado = "getTraffic: '" + parametro + "'"
    resultado
  }
  resultadoGetTraffic
}
val futureStep1: Future[String] = getEvent("PruebaEvent")
val futureStep2: Future[String] = {
  futureStep1.flatMap { response =>
    getTraffic(response)
  }
}
futureStep2.onComplete {
  case Success(value) => println("futureStep2 Success:" + value)
  case Failure(e) => println("futureStep2 Failure:" + e)
}

La salida de la ejecución es la siguiente:

import scala.util._
import scala.concurrent._
import ExecutionContext.Implicits.global
getEvent: (parametro: String)scala.concurrent.Future[String]
getTraffic: (parametro: String)scala.concurrent.Future[String]
futureStep1: scala.concurrent.Future[String] = Future(Success(getEvent: PruebaEvent))
futureStep2: scala.concurrent.Future[String] = Future(<not completed>)

Ejemplo 4: Future y tratamiento de errores con recover

Supongamos que en las funciones getEvent y getTraffic se producen errores; dichos errores, tenemos que controlarlos y, en el caso que se produzcan, tenemos que retornar un valor determinado; para estos casos, empleamos la función recover.

import akka.util.Timeout
import scala.concurrent.duration._
import scala.concurrent._
import ExecutionContext.Implicits.global
implicit val timeout = Timeout(2 seconds)
case class Resultado(evento: String, traffic: String)
def ejemplo1(): Unit = {
  def getEvent(parametro: String): Future[String] = {
    val resultadoGetEvent = Future {
    val resultado = "getEvent: " + parametro
    println(resultado)
    resultado
  }.recover {
    case e: Exception => "Valor getEvent por defecto"
  }
  resultadoGetEvent
}
def getTraffic(parametro: String): Future[String] = {
  val resultadoGetTraffic = Future {
    val resultado = "getTraffic: '" + parametro + "'"
    println(resultado)
    resultado
  }.recover {
    case e: Exception => "Valor getTraffic por defecto"
  }
  resultadoGetTraffic
}
val resultadoFutures = for {
  event <- getEvent("Parametro")
  traffic <- getTraffic(event)
} yield {
  Resultado(event, traffic)
}
val result = Await.result(resultadoFutures, timeout.duration)
println(s"->${result}")
}

La salida de la ejecución es la siguiente:

getEvent: Parametro
getTraffic: 'getEvent: Parametro'
->Resultado(getEvent: Parametro,getTraffic: 'getEvent: Parametro')

Ejemplo 5: Future y tratamiento de errores con recoverWith

El ejemplo anterior controla los errores pero, ¿qué hacemos cuando una excepción puede ser un resultado esperado?, o bien, ¿qué hacemos cuando se pueden producir muchos tipos de excepciones y queremos controlar el resultado para cada una de ellas?. En estos casos utilizamos la función recoverWith.

case class Resultado(evento: String, traffic: String)
def ejemplo3(): Unit = {
  def getEvent(parametro: String): Future[String] = {
    val resultadoGetEvent = Future {
    val resultado = "getEvent: " + parametro
    println(resultado)
    resultado
    throw new IllegalArgumentException(s"Error en parametro ${parametro}!")
  }.recoverWith {
    case ex: IllegalArgumentException => Future.successful(ex.getMessage)
    case e: Exception => Future.failed[String](new Exception("Error generico en getEvent"))
  }
  resultadoGetEvent
}
def getTraffic(parametro: String): Future[String] = {
  val resultadoGetTraffic = Future {
    val resultado = "getTraffic: '" + parametro + "'"
    println(resultado)
    resultado
  }.recoverWith {
    case ex: IllegalArgumentException => Future.successful(ex.getMessage)
    case e: Exception => Future.failed[String](new Exception("Error generico en getEvent"))
  }
  resultadoGetTraffic
}
val resultadoFutures = for {
  event <- getEvent("Parametro")
  traffic <- getTraffic(event)
  } yield {
    Resultado(event, traffic)
  }
  val result = Await.result(resultadoFutures, timeout.duration)
  println(s"->${result}")
}

El tratamiento del resultado de la función, se realiza empleando un for comprehension de forma secuencial y la función result de Await espera por la terminación de las dos funciones.

Otra posible opción para el control del resultado es utilizando algo como sigue:

resultadoFutures.onComplete {
  case Success(value) => println("Success: #" + value + "#")
  case Failure(e) => println("Failure:" + e)
}

La salida de la ejecución es la siguiente:

getEvent: Parametro
getTraffic: 'Error en parametro Parametro!'
->Resultado(Error en parametro Parametro!,getTraffic: 'Error en parametro Parametro!')

Ejemplo 6: Future y ejecución paralela con función fallbackTo

En ciertos momentos necesitamos que dos Future se ejecuten de forma paralela. En estos casos, utilizamos la función fallbackTo.

import akka.util.Timeout
import scala.concurrent.duration._
import scala.concurrent._
import ExecutionContext.Implicits.global
implicit val timeout = Timeout(2 seconds)
def ejemplo2(): Unit = {
  def getEventforma2(parametro: String): Future[String] = {
    val resultadoGetEvent = Future {
    val resultado = "getEvent: " + parametro
    Thread.sleep(2000)
    println("->" + resultado)
    resultado
  }
  resultadoGetEvent
}
def getTrafficforma2(parametro: String): Future[String] = {
  val resultadoGetTraffic = Future {
    val resultado = "getTraffic: '" + parametro + "'"
    println("=>" + resultado)
    resultado
  }
  resultadoGetTraffic
}
// Se ejecuta en paralelo el future getEventforma2 y getTrafficforma2
// El resultado será el resultado del primer future que termine.
// El Await espera a que terminen los dos Future.
val futureResultado = getEventforma2("PruebaEvent") fallbackTo getTrafficforma2("PruebaTraffic")
val resultado = Await.result(futureResultado, timeout.duration)
println(s"->$resultado")
}

Un posible solución puede ser la siguiente pero, en función del tiempo de ejecución, se puede producir una excepción de tipo TimeoutException.

=>getTraffic: 'PruebaTraffic'
->getEvent: PruebaEvent
->getEvent: PruebaEvent

Ejemplo 7: Future y ejecución paralela con función zip

Otra forma de ejecutar Future en paralelo es utilizando la función zip y, con esta función, al terminar cada una de las funciones, realizar el tratamiento. El siguiente  ejemplo muestra un ejemplo de uso.

def ejemplo1(): Unit = {
case class Resultado(aEvent:String, aTraffic:String)
def getEvent(parametro: String): Future[String] = {
  val resultadoGetEvent = Future {
    val resultado = "getEvent: " + parametro
    println(s"getEvent=${resultado}")
    Thread.sleep(3000)
    resultado
  }
  resultadoGetEvent
}
def getTraffic(parametro: String): Future[String] = {
  val resultadoGetTraffic = Future {
    val resultado = "getTraffic: '" + parametro + "'"
    println(s"getTraffic=${resultado}")
    resultado
  }
  resultadoGetTraffic
}
val resultado = (getEvent("param1") zip getTraffic("param2")) map {
  case (event, traffic) => {
    println("#event=" + event + " #traffic=" + traffic)
    Resultado(aEvent=event, aTraffic=traffic)
  }
}
val result = Await.result(resultado, timeout.duration)
println("resultado forma1=" + result)
}

La salida de la ejecución del código es la siguiente:

getTraffic=getTraffic: 'param2'
getEvent=getEvent: param1
#event=getEvent: param1 #traffic=getTraffic: 'param2'
resultado forma1=Resultado(getEvent: param1,getTraffic: 'param2')

Ejemplo 8: Future y ejecución paralela con for comprehension

El objeto Future es de  tipo monádico con lo cual podemos emplear for comprehension de la siguiente forma:

def ejemplo2(): Unit = {
case class ResultadoMonada(tarea1: String, tarea2: String)
def getTareaAsincrona1(): String = {
  val resultadoTarea = "Hacemos una tarea asíncrona1"
  Thread.sleep(2000)
  resultadoTarea
}
def getTareaAsincrona2(): String = {
  val resultadoTarea = "Hacemos una tarea asíncrona2"
  resultadoTarea
}
val getTareaAsincrona1Future = Future {
  getTareaAsincrona1()
}
val getTareaAsincrona2Future = Future {
  getTareaAsincrona2()
}
val resultMonada = for {
  resultado1 <- getTareaAsincrona1Future
  resultado2 <- getTareaAsincrona2Future
} yield {
  ResultadoMonada(tarea1 = resultado1, tarea2 = resultado2)
}
val result = Await.result(resultMonada, timeout.duration)
println("resultado Monada=" + result)
}

La salida de la ejecución del código es la siguiente:

resultado Monada=ResultadoMonada(Hacemos una tarea asíncrona1,Hacemos una tarea asíncrona2)

Ejemplo 9: Tratamiento de tareas Future para aquella que acabe primero

Hay necesidades funcionales en las cuáles necesitamos lanzar varias tareas y tratar aquel Future cuya ejecución termine el primero, despreciando al resto. En estos casos, empleamos la función firstCompletedOf. En el siguiente ejemplo, tomando las funciones del apartado anterior, el tratamiento del primer Future en terminar sería el siguiente:

// Arranca la tareaProgramada después de 200 milisegundos
val tareaProgramada1 = after(200 millis, using=system.scheduler)(getTareaAsincrona1Future)
val result1 = Future firstCompletedOf(Seq(tareaProgramada1, getTareaAsincrona2Future))
println(s"Resultado Prueba1:${result1}")

Una de las salidas de la ejecución del código anterior es el siguiente:

Success(Hacemos una tarea asíncrona2)

Otra posible codificación puede ser la siguiente:

[...]
// Tratamiento "quien acabe primero": resultado Exception porque future2 tarda mas en terminar.
val tareaProgramada2 = after(200 millis, using=system.scheduler)(Future.failed(new IllegalStateException("error!")))
val future2 = Future { Thread.sleep(1000); "foo" }
val result2 = Future firstCompletedOf(Seq(tareaProgramada2, future2))
result2 onComplete{
  case Success(resultado) => println(s"resultado2=${resultado}")
  case Failure(error) => println(s"error2=${error}")
}

Al lanzar la tareaProgramada2 una excepción, la salida de la ejecución del código anterior es la siguiente:

error2=java.lang.IllegalStateException: error!

Para finalizar el tipo de ejemplo, otra ejecución puede ser la siguiente:

val tareaProgramada3 = after(200 millis, using=system.scheduler)(Future.failed(new IllegalStateException("error!")))
val future3 = Future { "foo" }
val result3 = Future firstCompletedOf(Seq(tareaProgramada3, future3))
result3 onComplete{
  case Success(resultado) => println(s"resultado3=${resultado}")
  case Failure(error) => println(s"error3=${error}")
}

La salida del anterior snippet de código es la siguiente:

resultado3=foo

Estos son los ejemplos que presento, si al lector interesado se le ocurre plantear otro ejemplo, o bien, plantear cualquier otra alternativa, estaré encantado de compartirlo.

“Apache Kafka & Apache Spark: un ejemplo de Spark Streaming en Scala

En la presente entrada, “Apache Kafka & Apache Spark: un ejemplo de Spark Streaming en Scala”, describo cómo definir un proceso de streaming con Apache Spark con una fuente de datos Apache Kafka definido en lenguaje Scala.

La estructura del artículo está compuesta por los siguientes apartados:

  1.  Apache Kafka. En este apartado realizaré una breve presentación de Kafka, instalación y arranque de los elementos necesarios para el ejemplo.
  2.  Apache Spark. En este apartado realizaré una breve descripción de Spark streaming y la descripción del ejemplo a presentar.

Apache Kafka

Apache Kafka es aquella herramienta que permite construir pipeline de datos en tiempo real y streaming de aplicaciones. Apache kafka es tolerante a fallos y escalable horizontalmente.

Instalación.

El proceso de instalación es un proceso sencillo, simplemente, hay que realizar lo siguiente:

  1. Descarga del fichero comprimido con la herramienta.
  2. Descompresión del fichero descargado en una carpeta.
  3. Acceder a la carpeta principal y ejecutar los ficheros de inicio.

Para aquel lector interesado, existen varias imágenes de contenedores Docker de Kafka.

Inicio del Zookeeper y Kafka

Para iniciar Kafka es necesario ejecutar dos comandos: el primero, iniciar Zookeeper; y, el segundo, inicio del servidor de kafka. Para cada operación, es necesario la apertura de una consola. Así, los comandos son los siguientes:

  • Arranque de Zookeeper. La configuración de Zookeeper se encuentra en el fichero de configuración zookeeper.properties; para nuestro caso, empleamos la configuración por defecto. El comando para iniciar Zookeeper es el siguiente:
>./bin/zookeeper-server-start.sh config/zookeeper.properties
  • Arranque de kafka Server. La configuración de Apache Server se encuentra en el fichero de configuración server.properties; para nuestro caso, empleamos la configuración por defecto. El comando para iniciar el servidor de Kafka es el siguiente:
>./bin/kafka-server-start.sh config/server.properties

Creación de un topic de prueba

Apache Kafka trabaja con topics para el intercambio de información desde los productores hasta los consumidores. El comando para la creación del topic es el siguiente:

> ./bin/kafka-topics.sh --create --bootstrap-server localhost:9092 --replication-factor 1 --partitions 1 --topic test

Las opciones del script tienen el siguiente significado:

  • –create: opción de creación del topic.
  • –bootstrap-server localhost:9092 : opción para la definición del endpoint del servidor.
  • –replication-factor 1: opción para la definición del número de replicas del topic; en nuestro caso, valor 1.
  • –partitions 1: opción para defininir el número de particiones del topic; en nuestro caso, valor 1.
  • –topic test: nombre del topic a crear; en nuestro caso, test.

Creación de un productor.

Para la creación de un productor y realización de las pruebas, utilizaremos la herramienta de línea de comando con la cual nos permite el arranque de un productor; y, desde ésta, poder escribir aquel texto que se quiera generar.

El comando para el inicio del productor es el siguiente:

> ./bin/kafka-console-producer.sh --broker-list localhost:9092 --topic test

Una vez ejecutado, la consola se queda a la espera para la introducción del texto deseado.

Creación de un consumidor.

Para la creación de un consumidor y realización de las pruebas, utilizaremos la herramienta de línea de comando con la cual nos permite el arranque de un consumidor; y, desde esta, poder leer aquel texto que ha generado desde el productor.

El comando para el inicio del consumidor es el siguiente:

> ./bin/kafka-console-consumer.sh --bootstrap-server localhost:9092 --topic test --from-beginning

Las opciones del script tienen el siguiente significado:

  • –bootstrap-server localhost:9092 : opción para la definición del endpoint del servidor.
  • –topic test: nombre del topic a crear; en nuestro caso, test.
  • –from-beginning: opción para la definición del tipo de recepción.

Prueba de funcionamiento

Para la realización de un prueba de un productor y un consumidor, no hay mas que arrancar el productor en una terminal; arrancar el consumidor en una segunda terminal; y, por último,  escribir en el productor aquel texto que se quiera enviar al consumidor; como resultado de la ejecución, se visualizará en la terminal del consumidor el texto insertado en la terminal del productor.

Apache Spark

Apache Spark es un cluster de computación de proposito general el cual provee API en varios lenguajes como Java, Python y Scala, además de un motor  optimizado para la generación de gráficos. También soporta herramientas de alto nivel como son: Spark SQL, para el tratamiento de estructuras de datos; Spark MLLib, para machine learning; GraphX para el proceso gráfico y, por último, Spark Streaming.

Apache Spark Streaming es una extensión del core de Apache Spark con un API de alto rendimiento, escalable con un proceso de ingesta de datos tolerante a fallos. Los datos pueden ser ingestados desde distintas fuentes como son Kafka, Flume, un socket TCP,…; una vez ingestado, pueden ser procesados por funciones de orden superior; y, por último, el resultado del proceso puede ser almacenado en una base de datos, un fichero HDFS o un dashboard.

Gráficamente, Spark Streaming se puede definir de la siguiente forma:

Definición del problema

El problema que planteo es el siguiente: conexión de Apache Streaming con Apache kafka a traves de un topic con nombre test para poder cuantificar el número de palabras introducidas en un mensaje Kafka enviado al topic test desde un productor.

Definición de dependecias

Las dependencias necesarias para la realización del programa de interconexión son las siguientes:

  1. Definición de la dependecia de Spark Core
  2. Definición de la dependeicna con Spark Streaming
  3. Definición del conector de Spark con Kafka.

El objeto con las dependencias queda como sigue:

object Dependencies {
  val sparkVersion = "2.3.1"
  lazy val sparkCore = "org.apache.spark" %% "spark-core" % sparkVersion
  lazy val sparkStreamming = "org.apache.spark" %% "spark-streaming" % sparkVersion
  lazy val sparkStreamingKafka = "org.apache.spark" %% "spark-streaming-kafka-0-10" % "2.3.0"
}

El fichero build.sbt queda definido como sigue:

import Dependencies._
import sbt.Keys.libraryDependencies
ThisBuild / scalaVersion := "2.11.9"
ThisBuild / version := "0.1.0-SNAPSHOT"
ThisBuild / organization := "com.example"
ThisBuild / organizationName := "example"
lazy val root = (project in file("."))
.settings(
name := "ejem-spark",
scalacOptions += "-Ypartial-unification", // 2.11.9+
libraryDependencies += sparkCore,
libraryDependencies += sparkStreamming,
libraryDependencies += sparkStreamingKafka

Solución en Scala

La funcionalidad con la conexión a Kafka consiste en lo siguiente: definición del contexto de Spark y Spark Streaming, definición de la configuración a Kafka, creación del stream con la utilidad de Kafka, procesamiento del resultado; una vez definido, se realiza el arranque del contexto SparkStreaming y se queda a la espera de su finalización.

El código es el siguiente:

import org.apache.kafka.clients.consumer.ConsumerConfig
import org.apache.kafka.common.serialization.StringDeserializer
import org.apache.spark.SparkConf
import org.apache.spark.streaming._
import org.apache.spark.streaming.kafka010._
object EjemSparkStreamming {
  def exampleStreamming(): Unit = {
    val conf = new SparkConf().setMaster("local[2]").setAppName("EjemSparkStreamming-kafka")
    val ssc = new StreamingContext(conf, Seconds(2))
    val topics = "test" // lista de Topic de Kafka
    val brokers = "localhost:9092" // broker de Kafka
    val groupId = "0" // Identificador del grupo.
    // Create direct kafka stream with brokers and topics
    val topicsSet = topics.split(",").toSet
    val kafkaParams = Map[String, Object](
       ConsumerConfig.BOOTSTRAP_SERVERS_CONFIG -> brokers,
       ConsumerConfig.GROUP_ID_CONFIG -> groupId,
       ConsumerConfig.KEY_DESERIALIZER_CLASS_CONFIG -> classOf[StringDeserializer],
       ConsumerConfig.VALUE_DESERIALIZER_CLASS_CONFIG -> classOf[StringDeserializer])
    val messages = KafkaUtils.createDirectStream[String, String](
      ssc,
      LocationStrategies.PreferConsistent,
      ConsumerStrategies.Subscribe[String, String](topicsSet, kafkaParams))
    val lines = messages.map(_.value)
    val words = lines.flatMap(_.split(" "))
    val wordCounts = words.map(x => (x, 1L)).reduceByKey(_ + _)
    wordCounts.print()
    // Start the computation
    ssc.start()
    ssc.awaitTermination()
  }
  def main(args: Array[String]): Unit = {
    exampleStreamming()
  }
}

La configuración de conexión a Kafka se define en las variables topics, brokers y groupId. Topics, puede tener una lista de nombres de topic separados por comas; brokers, el endpoint de kafka; y, groupId, del grupo de topics, en nuestro caso no hemos definido. Todos los parámetros, se definen en la estructura Map kafkaParams.

KafkaUtils es aquel componente que realiza la definición del stream al cual se le pasa el contexto de Streaming, las estrategias de localización de los topic y la estrategia de consumidores.

Ejecución y prueba

Para realizar pruebas es necesario tener la infraestructura de Apache Kafka levantada y un productor arrancado; y, por la parte de Spark, arrancaremos la aplicación de forma normal. Así, ejecutaremos los siguiente pasos:

  • En la consola del productor, escribiremos el siguiente texto: “esto es una prueba de Streaming. esto es una prueba”
  • En la consola del programa, el cual estará ejecutándose constantemente, cada dos segundos, realizará la comprobación del topic con el siguiente escritura en la consola:
[...]
19/06/06 17:02:34 INFO Executor: Finished task 0.0 in stage 3.0 (TID 2). 1329 bytes result sent to driver
19/06/06 17:02:34 INFO TaskSetManager: Finished task 0.0 in stage 3.0 (TID 2) in 8 ms on localhost (executor driver) (1/1)
-------------------------------------------
Time: 1559833354000 ms
-------------------------------------------
(es,2)
(una,2)
(Streaming.,1)
(de,1)
(esto,2)
(prueba,2)
[...]

 

Creación de un proyecto Kotlin con Gradle

Las herramientas de gestión de ciclo de vida difieren en cada lenguaje, o bien, hay herramientas que soportan la gestión para diferentes lenguajes; por ejemplo: sbt, permite la creación y gestión de proyectos en Scala y Java; maven, permite la creación de proyectos Java, Scala o Kotlin; y, Gradle, permite la creación y gestión de proyectos en Scala, Java o Kotlin. En la entrada de hoy, Creación de un proyecto Kotlin con Gradle, me centraré en la definición de un proyecto base en lenguaje Kotlin con Gradle.

1.- Gradle

Gradle es una herramienta open source para la automatización y gestión de ciclo de vida software con el cual podemos definir script en lenguaje Groovy o con un DSL Kotlin. Es una herramienta flexible, rápida, customizable y permite la gestión de proyectos de distinto lenguajes, como pueden ser: Java, Android, Scala, Kootlin,…

Para el lector interesado, la versión actual es la 5.4.1 y la la referencia a la documentación es la siguiente.

1.1.- Instalación de Gradle

El proceso de instalación es un proceso característico en función del entorno de trabajo, ya sea Linux, Windows o Mac. La referencia documental de instalación es la siguiente. 

En mi caso, el entorno de trabajo es sobre sistema Linux, en el cual el proceso de instalación consiste en lo siguiente: realizar la descarga de Gradle, descompresión del fichero descargado sobre un carpeta; y, por último, definir la variable de entorno. Para confirmar la instalación, se ejecuta el siguiente comando en una terminal:

gradle -v

La salida del comando tiene el siguiente aspecto:

 ------------------------------------------------------------
Gradle 5.4.1
------------------------------------------------------------

Build time: 2019-04-26 08:14:42 UTC
Revision: 261d171646b36a6a28d5a19a69676cd098a4c19d

Kotlin: 1.3.21
Groovy: 2.5.4
Ant: Apache Ant(TM) version 1.9.13 compiled on July 10 2018
JVM: 1.8.0_201 (Oracle Corporation 25.201-b09)
OS: Linux 4.6.7-040607-generic amd64

 

2.- Creación del proyecto

Una vez que tenemos Gradle instalado en la máquina, el proceso de creación del proyecto es sencillo y parecido a otras herramientas.

El proceso se define en los siguientes pasos:

  1. Creación de una carpeta del proyecto. La creación del directorio lo realizamos creando desde la línea de comandos una carpeta; en el presente caso, se ejecuta el siguiente comando: mkdir ejem2-kotlin. Una vez ejecutado, nos situamos en el interior de la carpeta mediante el comando cd ejem2-kotlin.
  2. Inicialización del proyecto. La inicialización del proyecto consiste en aquel proceso en el cual se realiza la creación de la estructura del proyecto. Dicho proceso, se realiza ejecutando el siguiente comando: gradle init. La consecuencia de este comando es la ejecución de un wizard en el cual se solicita una serie de cuestiones, entre ellos, selección de lenguaje (permite la creación de proyectos en Java, Korlin o Scala), nombre del proyecto y estructura de carpetas.

La estructura de carpetas del proyecto desde el visor de proyectos del IDE IntelliJ es el siguiente:

La estructura de carpetas y ficheros creados a destacar son los siguientes:

  • src.- Carpeta de código fuente con el aspecto típico, contiene la carpeta src/main/kotlin y src/test/kotlin; además, de las carpetas resources.
  • build.- carpeta con el contenido generado por el compilador kotlin.
  • out.- carpeta con el resultado de la compilación del proyecto.
  • gradle.- carpeta con los wrapper de gradle.
  • .gitignore.- fichero git.
  • build.gradle.kts.- fichero gradle con la configuración.
  • settings.gradle.kts.- fichero con propiedades.
  • gradlew.bat y gradlew.sh.- Fichero de ejecución Gradle del proyecto.

3.- Fichero de construcción build.gradle.kts

El fichero build.gradle.kts es aquel fichero en donde definimos la configuración necesaria para trabajar con el proyecto, como por ejemplo: las dependencias, repositorios y la clase principal.

La estructura del fichero está compuesta por los siguientes apartados:

  • plugins.- definición de las referencias de plugins existentes.
  • repositories.- definición de las referencias a los repositorios de artefactos.
  • dependencies.- definición de los artefactos dependientes en el proyecto.
  • application.- definición de la configuración de la aplicación, en concreto, la definición de la clase principal.

Un ejemplo de fichero build.gradle.kts para un proyecto en lenguaje Kotlin con las dependencias de la librería Arrow es la siguiente:

 import org.jetbrains.kotlin.kapt3.base.Kapt.kapt
/*
* This file was generated by the Gradle 'init' task.
*
* This generated file contains a sample Kotlin application project to get you started.
*/
plugins {
  // Apply the Kotlin JVM plugin to add support for Kotlin on the JVM.
  id("org.jetbrains.kotlin.jvm").version("1.3.21")
  kotlin("kapt") version "1.3.31"
  // Apply the application plugin to add support for building a CLI application.
  application
}
repositories {
  // Use jcenter for resolving your dependencies.
  // You can declare any Maven/Ivy/file repository here.
  jcenter()
  mavenCentral()
}
val arrow_version = "0.9.0"
dependencies {
  // Use the Kotlin JDK 8 standard library.
  implementation("org.jetbrains.kotlin:kotlin-stdlib-jdk8")
  // Use the Kotlin test library.
  testImplementation("org.jetbrains.kotlin:kotlin-test")
  // Use the Kotlin JUnit integration.
  testImplementation("org.jetbrains.kotlin:kotlin-test-junit")
  compile( "io.arrow-kt:arrow-core-data:$arrow_version")
  compile( "io.arrow-kt:arrow-core-extensions:$arrow_version" )
  compile( "io.arrow-kt:arrow-syntax:$arrow_version")
  compile( "io.arrow-kt:arrow-typeclasses:$arrow_version")
  compile( "io.arrow-kt:arrow-extras-data:$arrow_version")
  compile( "io.arrow-kt:arrow-extras-extensions:$arrow_version")
  kapt( "io.arrow-kt:arrow-meta:$arrow_version")
  compile( "io.arrow-kt:arrow-query-language:$arrow_version") //optional
  compile( "io.arrow-kt:arrow-free-data:$arrow_version") //optional
  compile( "io.arrow-kt:arrow-free-extensions:$arrow_version") //optional
  compile( "io.arrow-kt:arrow-mtl:$arrow_version") //optional
  compile( "io.arrow-kt:arrow-effects-data:$arrow_version") //optional
  compile( "io.arrow-kt:arrow-effects-extensions:$arrow_version") //optional
  compile( "io.arrow-kt:arrow-effects-io-extensions:$arrow_version") //optional
  compile( "io.arrow-kt:arrow-effects-rx2-data:$arrow_version") //optional
  compile( "io.arrow-kt:arrow-effects-rx2-extensions:$arrow_version") //optional
  compile( "io.arrow-kt:arrow-effects-reactor-data:$arrow_version") //optional
  compile( "io.arrow-kt:arrow-effects-reactor-extensions:$arrow_version") //optional
  compile( "io.arrow-kt:arrow-optics:$arrow_version") //optional
  compile( "io.arrow-kt:arrow-generic:$arrow_version") //optional
  compile( "io.arrow-kt:arrow-recursion-data:$arrow_version") //optional
  compile( "io.arrow-kt:arrow-recursion-extensions:$arrow_version") //optional
  compile( "io.arrow-kt:arrow-query-language:$arrow_version") //optional
  compile( "io.arrow-kt:arrow-integration-retrofit-adapter:$arrow_version") //optional
}
application {
  // Define the main class for the application.
  mainClassName = "es.ams.AppKt"
}

4.- Comandos Gradle

Gradle es una herramienta con la cual se ejecutan tareas con una funcionalidad determinada. En el presente apartado, identificaré un conjunto de comandos para la ejecución de ciertas tareas mínimas.

Un conjunto de tareas básicas son las siguientes:

  • gradle clean.- Eliminación de la carpeta build.
  • gradle build.- Construcción de los componentes binarios del proyecto.
  • gradle tasks.- visualización de las tareas definidas en el proyecto.
  • gradle properties.- visualización de las propiedades definidas en el proyecto.
  • gradle run.– Ejecución del proyecto.
  • gradle projects.- visualización de la información del proyecto.
  • gradle tests.- Ejecución de los test definidos en el proyecto.

Si se utiliza un IDE como IntelliJ, una vez importado y configurado la ubicación de Gradle, se pueden ejecutar desde la propia herramienta. Un aspecto de la estructura, contenido de clases y dependencias es el que se representa en la siguiente imagen:

5.- Conclusiones

La entrada define aspectos básicos y genéricos de Gradle. El objetivo de la entrada es la creación de un proyecto básico de Gradle en lenguaje Kotlin que permita a una persona realizar la creación de un proyecto y empezar a trabajar en dicho entorno.

Si realizamos un proceso comparativo a alto nivel con otros herramientas, el proceso es similar y, en concreto, me ha resultado una forma de trabajo parecida a la herramienta sbt para la gestión de proyectos en lenguaje Scala.

Validated: control de errores

En toda aplicación software es necesario realizar tareas de validación de campos, validación de formularios,o bien, verificación de una función;y, una vez realizadas las validaciones individuales, es necesario realizar la validación del conjunto de todas ellas. En la entrada de hoy, Validated: control de errores, me centraré en describir y realizar un ejemplo de validación de los campos de un formulario representado en una estructura de tipo Map.

Supongamos que estamos desarrollando una aplicación en la cual tenemos un formulario de dos elementos: el primero, el campo nombre; y, el segundo, el campo edad. Las validaciones que tenemos que realizar son: validación del campo nombre, validación del campo edad y evaluación de la validación del conjunto del formulario.

El campo nombre debe de ser un campo que no sea vacío. El campo edad debe de ser un
campo no vacío, entero y mayor que cero.

Las validaciones se realizan mediante el tipo Validated el cual no está definido como un tipo estándar de Scala, está definido en la librería Cats. La importación del tipo Validated y el resto de importaciones necesarias para el ejemplo son las siguientes:

import cats.data.Validated
import cats.instances.list._
import cats.syntax.all._

El primer paso a realizar es realizar la definición de los alias de todas las estructuras sobre las que trabajaremos. Los alias son los siguientes:

  • Definición del formulario. El formulario es una estructura de tipo Map.
type Form = Map[String, String]
  • Definición de la estructura de control de error sencillas. Las verificaciones
    sencillas se realizarán con un elemento de tipo Either
type ControlErrorFast[A] = Either[List[String], A]
  • Definición de la estructura de control de error compleja o validación. Las verificaciones complejas se realizarán con un elemento de tipo Validated.
type ValidatedForm[A] = Validated[List[String], A]

La primera operación a realizar es la obtención de un elemento del formulario. Para
realizar dicha operación, definiremos la función getValue de la siguiente manera:

def getValue(form: Form)(campo: String) : ControlErrorFast[String] = 
  form.get(campo)
    .toRight(List(s"El valor de $campo no está especificado"))

La segunda operación es realizar la verificación del campo nombre. Para realizar dicha operación, definimos la función readName y sus funciones auxiliares. El código es el siguiente:

def nonBlank(nombre:String)(dato:String): ControlErrorFast[String] =
   Right(dato)
    .ensure(List(s"El campo $nombre no debe de ser vacío."))
     (_.nonEmpty)

def readName(form: Form): ControlErrorFast[String] =
  getValue(form)("name")
   .flatMap( elem => nonBlank("name")(elem))

def nonBlank(nombre:String)(dato:String): ControlErrorFast[String] =
  Right(dato) 
   .ensure(List(s"El campo $nombre no debe de ser vacío."))
    (_.nonEmpty)

La tercera operación es realizar la verificación del campo edad. Para realizar dicha
operación, definiremos la función readAge y sus funciones auxiliares. El código es el
siguiente:

def readAge(form: Form): ControlErrorFast[Int] =
  getValue(form)("age")
   .flatMap(nonBlank("age"))
   .flatMap(parseInt("age"))
   .flatMap(nonNegative("age"))

def parseInt(nombre:String)(age:String): ControlErrorFast[Int] =
  Either.catchOnly[NumberFormatException](age.toInt)
   .leftMap(_ => List(s"El campo $nombre debe de ser numérico"))

def nonNegative(nombre:String)(dato:Int): ControlErrorFast[Int] =
  Right(dato)
   .ensure(List(s"El campo $nombre no es válido"))
    (_ >= 0 )

Para finalizar, una vez realizadas las verificaciones de los campos, es necesario realizar la validación del formulario para obtener el listado de los posibles errores presentes en el formulario, o bien, retornar el resultado final.

La validación del formulario se realiza utilizando elementos de tipo Validated y un elemento que trabaje con los contextos de validación; dicho elemento, es un Semigroupal el cual genera una tupla de elementos del mismo contexto.

val formHtml: Form = Map("name" -> "Pepito", "age" -> "40")
val valid1_1:ValidatedForm[String] = Validated.fromEither(readName(formHtml))
val valid1_2:ValidatedForm[Int] = Validated.fromEither(readAge(formHtml))
val resultado1 = (valid1_1, valid1_2).tupled
println(s"resultado1=${resultado1}")

La salida por consola es la siguiente:

resultado1=Valid((Pepito,40))

Para el supuesto de trabajar con un formulario con datos erróneos, el código sería el siguiente:

val formHtmlKO3: Form = Map("name" -> "", "age" -> "-1")
val valid4_1:ValidatedForm[String] = Validated.fromEither(readName(formHtmlKO3))
val valid4_2:ValidatedForm[Int] = Validated.fromEither(readAge(formHtmlKO3))
val resultado4 = (valid4_1, valid4_2).tupled
println(s"resultado4=${resultado4}")
println

La salida por consola es la siguiente:

resultado4=Invalid(List(El campo name no debe de ser vacío., El campo age no es válido))

Como conclusión final, una de las opciones para el control de errores es utilizar el componente Either, pudiendo controlar los valores y las excepciones. Cuando todos los elementos Either son agrupados para su evaluación con Validated y un Semigropal podemos obtener el resultado, o bien, el conjunto de los mensajes de las no validaciones que se han producido en el mismo instante. A diferencia de otros procesos de validación, la ventaja reside en que conocemos todos los fallos producidos en el mismo tiempo.

 

Test unitarios y cobertura de código en Python

En la presente entrada, Test unitarios y cobertura de código en Python, realizaré la descripción de cómo se realizan test unitarios en Python con unittest y, además, cómo se realizan el análisis del código para generar el índice de cobertura de código con la herramienta coverage.

Los ejemplos estarán realizados con la versión 3.6 de Python.

logo-python

Test unitarios

Los test unitarios los definimos utilizando el framework unittest el cual está incorporado en la distribución de la versión del lenguaje.

Para realizar un test de un código, iniciaremos la definición de un código al cual se definirán el conjunto de test a definir. Este proceso inicial lo realizaré para comprender el proceso.

Definiré una clase de utilidad Util con un método statusToCode cuya funcionalidad consistirá en parsear un parámetro alfanumérico de entrada y, como salida, retornará un valor entero.

El snippet de la clase es la siguiente:

class Util:
  """Class utils."""
  @staticmethod
  def statusToCode(code="") -> int:
    """Return exit code"""
    assert len(code) > 0, "Argument not valid"
    result = {
      'UP': 0,
      'WARNING': 1,
      'CRITICAL': 2,
      'UNKOWN': 3,
    }.get(code, 3)
    return result

La clase Util está definida en el módulo util.py dentro de la carpeta lib. La función statusToCode tiene un decorador definido con nombre @staticmethod el cual permite definir el método en la clase con referencia estática para poderlo utilizar sin la necesidad de instanciar la clase.

Los test los definiremos en la carpeta lib_test la cual está definida al mismo nivel que la clase lib. Definiré las clases de test conforme a los módulos definidos. Así, tendremos la clase UtilTest en el módulo test_utils.py de la carpeta lib_test.

La clase UtilTest deberá de importar el módulo unittest y definir la clase heredando de la clase unittest.TestCase para poder realizar los test. Además, deberá de importar la clase con el código que se desea probar. Así, la clase queda definida de la siguiente forma:

import unittest
from lib.utils import Util

class UtilTests(unittest.TestCase):
  def setUp(self):
    pass

  def test_statusToCode_EMPTY(self):
    try:
      print(sys.executable)
      Util.statusToCode("")
    except AssertionError as exception:
      self.assertTrue(exception != None)

  def test_statusToCode_UP(self):
    self.assertEqual(Util.statusToCode("UP"), 0)

  def test_statusToCode_WARNING(self):
    self.assertEqual(Util.statusToCode("WARNING"), 1)

  def test_statusToCode_CRITICAL(self):
    self.assertEqual(Util.statusToCode("CRITICAL"), 2)

  def test_statusToCode_UNKNOWN(self):
    self.assertEqual(Util.statusToCode("UNKNOWN"), 3)

La clases UtilTests presenta seis métodos: el método setUp, el cual realiza la definición de las operaciones previas a la ejecución de los test, en nuestro caso no es necesario realizar ninguna; y, el resto de métodos, que definen los test al tener como prefijo la cadena “test_”.

La verificación de los resultados se realiza empleando la referencia self la cual define las funciones de comprobación.

Cobertura

La cobertura de código la realizaremos con la herramienta coverage cuya referencia la pondremos en el fichero requirements.txt para que sea cargado en el entorno virtual del proyecto.

La herramienta coverage tiene la capacidad de realizar la generación de los informes por línea de comando, o bien, la generación de los informes en formato html; dichos informes, se generarán en la carpeta htmlcov del propio proyecto.

Los comandos que ejecutaremos son los siguientes:

  • coverage erase.- Eliminación de los datos previos de cobertura. Un ejemplo de ejecución en la línea de comandos es el siguiente: coverage erase
  • coverage run.- Arranque del programa Python que recolecta los datos. Un ejemplo de ejecución en la línea de comandos es el siguiente: coverage run –omit=’.tox/*,.venv/*’ -m unittest
  • coverage report.- Generación resultados. Un ejemplo de ejecución en la línea de comandos es el siguiente:  coverage report –omit=’.tox/*,venv/*’ -m
  • coverage html.- Generación de los informer en formato HTML. Un ejemplo de ejecución en la línea de comandos es el siguiente: coverage html –omit=’.tox/*,venv/*’

Un ejemplo de informe de cobertura tiene el siguiente aspecto:

python coverage html

Automatización del proceso de Cobertura

En el apartado anterior, he definido la forma de ejecutar los test y la Generación de los informes de cobertura y, en el presente apartado, realizaré la descripción de cómo lo podemos automatizar.

La automatización la realizamos empleando la herramienta tox(https://tox.readthedocs.io/en/latest/) Para poder utilizar tox, primeramente, es necerios definir en el fichero requirement.txt la herramienta tox; una vez instalado en el entorno virtual, deberemos definir el plan de ejecución de tox el cual se define en el fichero tox.ini ubicado en la carpeta raíz del proyecto.

El aspecto del fichero tox es el siguiente:

[tox]
envlist = py36, coverage-report
skipsdist = True

[testenv]
commands = python -m pytest {posargs}
deps =
-r{toxinidir}/requirements.txt
freezegun==0.3.9
pytest==3.5.0
passenv=*

[testenv:coverage-report]
skip_install = true
commands =
coverage erase
coverage run --omit='.tox/*,.venv/*' -m unittest
coverage report --omit='.tox/*,venv/*' -m
coverage html --omit='.tox/*,venv/*'

El fichero tox está compuesto de tres elementos de configuración los cuáles tienen la siguiente descripción:

  • Elemento tox: Definición del entorno virtual de ejecución, elemento a ejecutar y el flag de generación del artefacto para la distribución
  • Elemento testenv: Definición de la configuración necesaria por tox.
  • Elemento coverage-report: Definición de la secuencia de comandos de la herramienta coverage para el cálculo y generación de informes de cobertura.

Para ejecutar el proceso automático tecleamos en la línea de comando y posicionados en la carpeta de proyecto el comando tox.

Conclusión

El proceso de generación de test unitartios en Python es un proceso parecido a otros lenguajes como Java o Scala. Además, al estár el framework incorporado en la distribución no requiere de ninguna operación de carga, facilitando su uso.

 

Cats I: Mónada Eval

En entrada anteriores, he hablado de cierto tipo de mónada como son la mónada Reader o la mónada Estado con la librería Scalaz. En la entrada de hoy, Cats: Mónada Eval, me centraré en la mónada Eval definida en la librería Cats. La librería Cats es una de las librerías básica del ecosistema de Scala como lo es librería Scalaz.

Tipos de evaluación en Scala

La definición de variables con la palabra reservada val en Scala implica la definición de una variable inmutable. Por otro lado, si se quiere definir una variable mutable, se emplea la palabra reservada var.

Para los valores inmutables, se puede definir qué evaluación tiene una variable; es decir, se puede definir si una variables tiene evaluación inmediata o perezosa; pero, además, se puede definir si el valor es cacheado o no. Así, podemos definir variables de la siguiente forma:

  •  Variable con la palabra reservada val.– Definición de una variable con evaluación inmediata y memorizable.

Un ejemplo es el siguiente:

val x = {
  println("Procesando X")
  Math.random
}
println(x)
println(x)

La salida por consola es la siguiente:

Procesando X
0.49063463192831624
0.49063463192831624
  • Variable con las palabras reservadas lazy y val.- Definición de una variable con evaluación perezosa y memorizable.
lazy val x = {
  println("Procesando X")
  Math.random
}
println(x)
println(x)

La salida por consola es la siguiente:

Procesando X
0.7903293397160105
0.7903293397160105
  • Variable con la palabra reservada def.- Definición de una variable con evaluación perezosa y no memorizable.
def x = {
  println("Procesando X")
  Math.random
}
println(x)
println(x)

La salida por consola es la siguiente:

Procesando X
0.8181569326322171
Procesando X
0.2682764923719232

2.- Mónada Eval. Tipos de evaluación con Cats

La librería Cats define una mónada para controlar las evaluaciones. La mónada es un wrapper de un valor o de una computación que produce un valor. Además, Eval soporta una computación perezona segura para una pila mediante los métodos map y flatMap.

Los tipos de Eval son los siguientes:

  • Eval.now.- La evaluación now es equivalente a val. Un ejemplo es el siguiente:
import cats.Eval
val x = Eval.now{
println("Procesando X")
Math.random
}
println(x.value)
println(x.value)

La salida por consola es la siguiente:

Procesando X
0.8337324158188836
0.8337324158188836
  • Eval.later.- La evaluación later es equivalente a lazy val. Un ejemplo es el siguiente:
import cats.Eval
val x = Eval.later{
  println("Procesando X")
  Math.random
}
println(x.value)
println(x.value)

La salida por consola es la siguiente:

Procesando X
0.8335294714853098
0.8335294714853098
  • Eval.always.- La evaluación always es equivalente a def. Un ejemplo es el siguiente:
val x = Eval.always{
  println("Procesando X")
  Math.random
}
println(x.value)
println(x.value)

La salida por consola es la siguiente:

Procesando X
0.36159399101292466
Procesando X
0.7171589355658571
  •  Otros ejemplos:

Procesamiento de una computación Eval.always y función map

val greeting = Eval
  .always{ println("Paso 1"); "Hello"}
  .map{ str => println("Paso 2"); s"${str} world" }
println(greeting.value)

La salida por consola es la siguiente:

Paso 1
Paso 2
Hello world

Computación de operaciones Eval de tipo now y always en una for comprehension .

val ans = for{
  a <- Eval.now{ println("Calculating A"); 40 }
  b <- Eval.always{ println("Calculating B "); 2 }
}yield{
  println("Sumando A y B")
  a + b
}
println(s"Calculo1=${ans.value}")
println
println(s"Calculo2=${ans.value}")
println

La salida por consola es la siguiente:

Calculating A
Calculating B
Sumando A y B
Calculo1=42
Calculating B
Sumando A y B
Calculo2=42

3.- Otras operaciones

La mónada Eval es interesante su uso en una computación que retorne un valor; pero, hay ocasiones que se necesita cachear un valor o deferir la computación para evitar una excepción de tipo StackOverflow. Para ello, están las funciones memoize y defer.

3.1.- Función memoize.

La función memoize permite el cacheo de un valor, o bien, la cadena de una computación. Un ejemplo es el siguiente:

val saying = Eval
 .always{ println("Paso 1"); "Un gato" }
 .map{ str => println("Paso 2"); s"${str} siéntate" }
 .memoize
 .map{ str => println("Paso 3"); s"${str} la alfombra" }
println(s"Calculo1=${saying.value}")
println
println(s"Calculo2=${saying.value}")

La salida por consola es la siguiente:

Paso 1
Paso 2
Paso 3
Calculo1=Un gato siéntate la alfombra
Paso 3
Calculo2=Un gato siéntate la alfombra

3.2.- Función defer.

Las funciones para la manipulación de valores con Eval es mediante las funciones map y flatMap. Así, con las sucesivas llamadas se van apilando una conjunto de operaciones que, una vez apiladas todos los posibles casos, se realiza el cálculo.

Un ejemplo de este escenario, es el cálculo del factorial con la multiplicación del número n en cada llamada. El código es el siguiente:

def factorial(n: BigInt): Eval[BigInt] ={
  if(n==1){
    Eval.now(n)
  }else{
    factorial(n-1).map( _ * n )
  }
}
println( factorial(50000).value )

La salida por consola sería la siguiente:

Exception in thread "main" java.lang.StackOverflowError

Para evitar esta situación, podemos emplear la función defer con la cual diferimos la ejecución de una expresión que produce un valor de Eval. Es como un flatMap pero seguro.

El ejemplo anterior utilizando la función defer queda como sigue:

def factorial2(n: BigInt): Eval[BigInt] ={
  if(n==1){
    Eval.now(n)
  }else{
    Eval.defer( factorial2(n-1).map( _ * n ) )
  }
}
println( factorial2(50000).value )

La salida por consola sería el resultado del cálculo. Al ser un número muy grande, lo omito.

4.- Función fold con Eval

Para realizar el cálculo de un valor de un ADT es común la utilización de la función fold. En el siguiente ejemplo, se muestra la definición de la función fold y el cálculo de la suma de los elementos de una lista. El código es el siguiente:

def miFoldRightEvalList[A, B](list: List[A], empty: Eval[B])(f: (A, Eval[B]) => Eval[B]): Eval[B] = list match {
  case Nil => empty
  case head :: tail => Eval.defer( f(head, miFoldRightEvalList(tail, empty)(f) ) )
}

def mifoldRight[A,B](as: List[A], acc:B)(fn: (A,B) => B): B =
  miFoldRightEvalList(as, Eval.now(acc)){
    (a,b) => b.map( fn(a,_) )
  }.value

val miLista2 =  (1 to 10000000).toList
println(s"Suma de la lista= ${mifoldRight( miLista2, 0L)(_+_) } ")
println

La salida por consola es la siguiente:

Suma de la lista= 50000005000000

La mónada Eval nos permite tener una seguridad en la ejecución de una cadena de expresiones evitando el desbordamiento de la pila del sistema.