¿Cómo puedo escalo mi solicitud Scala REST que utiliza Akka?

Question

Tengo una aplicación usando Scala Akka que recibe peticiones REST, hace que algunas operaciones contra una base de datos, y responde con un poco de información al cliente. Como es, las operaciones de mi db toman mucho tiempo y mi actor REST habilitado es incapaz de responder a las nuevas demandas, mientras tanto, a pesar de que podría correr una gran cantidad de operaciones al mismo tiempo contra el PP. Estoy usando las anotaciones javax.ws.rs para descansar a habilitar métodos en mi actor.

La cuestión; ¿cuál es la mejor manera para que mi aplicación para manejar un gran número de solicitudes simultáneas?

Editar . Voy a añadir un código de ejemplo

  import se.scalablesolutions.akka.actor._
  import javax.ws.rs._

  @Path("/test")
  class TestService {

    @GET
    def status() = 
      actorPool !! Status(session).
        getOrElse(<error>Unable to connect to service</error>)
  }

  class TestActor {

    def receive = {
      case Status() => {
        reply(SomeObject.slowDBMethod)
      }
    }
  }

  case class Status()

Edit2 : Esto es lo que estoy haciendo en el registro. Voy a enviar a las tres peticiones de mi navegador lo más rápido que puedo cambiar de pestaña y presione F5, pero el grano de RS todavía espera para la primera solicitud para completar antes de manipular el siguiente.

[INFO] [2010-08-29 16:27:03,232] [akka:event-driven:dispatcher:global-15] c.n.StatusActor: got Slow request
[INFO] [2010-08-29 16:27:06,916] [akka:event-driven:dispatcher:global-10] c.n.StatusActor: got Slow request
[INFO] [2010-08-29 16:27:10,589] [akka:event-driven:dispatcher:global-3] c.n.StatusActor: got Slow request

Answer 1

Mientras me di cuenta de este hilo es de + 4 meses rancio ahora, vale la pena señalar que Akka tiene una nueva implementación del módulo HTTP que transfiere la petición en un actor de manera eficiente. Este enfoque aprovecha la API servlet asíncrono (también funciona con continuaciones Jetty) para permitir que la solicitud suspendido para ser pasado a través del sistema como un mensaje y se reanuda en cualquier punto; eliminando, por ejemplo, la necesidad de utilizar !! de desencadenar la obra actor y responden en el POJO anotada. Del mismo modo, dado que la solicitud se suspende en el recipiente, y el contexto se voltea en un actor tan rápido como sea posible, no hay hilos de bloqueo para manejar la respuesta o futuro.

Una forma ingenua el ejemplo anterior podría reescribirse hoy:

class TestEndpoint extends Actor with Endpoint {
   def hook(uri:String) = uri == "/test"
   def provide(uri:String) = actorOf[TestService].start

   override def preStart = {
     ActorRegister.actorsFor[classOf[RootEndpoint]).head ! Endpoint.Attach(hook, provide)
   }

   def receive = handleHttpRequest
}

class TestService extends Actor {
   def receive = {

     case get:Get => 
       get.timeout(SomeObject.TimeoutInSeconds) // for example
       get.OK(SomeObject.slowDBMethod)

     case other:RequestMethod =>
      other.NotAllowed("Invalid method for this endpoint")
   }
}

Más documentación se puede encontrar en el sitio akka: http://doc.akkasource.org/http

Answer 2

Parece que usas una versión anterior de Akka.

Te recomiendo actualizar a 0,10 (que separa los Actores y RS-Beans), entonces se puede utilizar LoadBalancer 1 (y 2 ) del acelerador la carga de trabajo, o tomar ventaja de la WorkStealingDispatcher 3 (y 4 )

¿Eso ayuda?

Answer 3

Una vez que obtenga una solicitud, se debe crear un nuevo actor para manejar esa solicitud. Transmitir el emisor original, de modo que el actor recién creada sabe que para responder a.

Answer 4

A pesar de que este hilo es viejo, me gustaría añadir a la mezcla Spiffy (enchufe!):

https://github.com/mardambey/spiffy

¿Qué es Spiffy?

Spiffy ...

• está escrito en Scala
• utiliza la biblioteca fantástica Akka y actores a escala
• utiliza servlet API 3.0 para servir peticiones de asíncrona
• es modular (sustitución de componentes es directo)
• usos DSL para reducir el código en el que no desea que
• apoya la solicitud ganchos alrededor de controladores

Spiffy es un framework de desarrollo web usando Scala, Akka (una implementación actor de Scala), y la API de Java 3.0 Servelet. Se hace uso de la interfaz asíncrona y el objetivo es proporcionar una paralela masiva y el medio ambiente escalable para aplicaciones web. Los distintos componentes del spiffy todos se basan en la idea de que tienen que ser módulos independientes minimalistas que hacen pequeñas cantidades de trabajo muy rápidamente y mano de la petición al siguiente componente en la tubería. Después de que el último componente se realiza el procesamiento de la solicitud se señala el contenedor de servlets por "completar" la solicitud y enviarla de vuelta al cliente.