Come mi scala la mia domanda Scala REST che utilizza Akka?

Question

Ho un'applicazione Scala utilizzando Akka che riceve le richieste REST, rende alcune operazioni contro un database, e risponde con alcune informazioni al client. Così com'è, le mie operazioni db richiedere molto tempo e il mio attore REST-enabled è in grado di rispondere alle nuove richieste nel frattempo, anche se ho potuto eseguire un sacco di operazioni contemporaneamente contro il DB. Sto utilizzando le javax.ws.rs annotazioni di REST-abilitare metodi in mio attore.

La domanda; qual è il modo migliore per consentire la mia applicazione per gestire un gran numero di richieste simultanee?

Modifica :. Io aggiungo alcuni esempi di codice

  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 : Questo è quello che sto ottenendo nel registro. Sto inviando le tre richieste dal mio browser più veloce che posso passare le schede e premere F5, ma il fagiolo RS attende ancora per la prima richiesta per completare prima di maneggiare la successiva.

[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

Mentre realizzo questa discussione è 4+ mesi stantio ora, vale la pena notare che Akka ha una nuova implementazione modulo HTTP che trasferisce la richiesta in un attore efficientemente. Questo approccio sfrutta l'API servlet asincrono (funziona anche con continuazioni molo) per abilitare la richiesta sospesa da passare attraverso il sistema come un messaggio e ripreso in qualsiasi momento; eliminando, per esempio, la necessità di utilizzare !! al grilletto lavoro attore e rispondere nel POJO annotati. Analogamente, poiché la richiesta viene sospeso nel contenitore, e il contesto è capovolto in un attore il più velocemente possibile, non ci sono fili che bloccano per gestire la risposta o futura.

Un modo ingenuo l'esempio precedente potrebbe essere riscritta oggi:

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")
   }
}

Ulteriore documentazione può essere trovata sul sito Akka: http://doc.akkasource.org/http

Answer 2

ti sembra stia usando una vecchia versione di Akka.

Vi consiglio di passare a 0,10 (che separa Attori e RS-Fagioli), quindi è possibile utilizzare LoadBalancer 1 (e 2 ) a manetta il carico di lavoro, o di approfittare della WorkStealingDispatcher 3 (e 4 )

fa questo aiuto?

Answer 3

Una volta che si riceve una richiesta, è necessario creare un nuovo attore per gestire tale richiesta. Passare al mittente originale in modo l'attore appena creato sa che per rispondere a.

Answer 4

Anche se questa discussione è vecchio, mi piacerebbe aggiungere Spiffy al mix (spina!):

https://github.com/mardambey/spiffy

Che cosa è Spiffy?

Spiffy ...

• è scritto in Scala
• utilizza la fantastica libreria di Akka e attori di scala
• utilizza API servlet 3.0 per la manipolazione richiesta asincrona
• è modulare (sostituzione di componenti è semplice)
• usi DSL per ridurre il codice in cui non si desidera che
• appoggia la richiesta ganci intorno controller

Spiffy è un framework web utilizzando Scala, Akka (un'implementazione attore Scala), e il 3.0 API Java Servelet. Si avvale del l'interfaccia asincrona e mira a fornire un massicciamente parallela e ambiente scalabile per le applicazioni web. vari componenti di Spiffy sono tutte basate sull'idea che hanno bisogno di essere moduli minimaliste indipendenti che fanno piccole quantità di lavoro molto rapidamente e la mano fuori la richiesta al componente successivo nella pipeline. Dopo l'ultimo componente è fatto l'elaborazione della richiesta segnala il servlet container per "completare" la richiesta e inviarlo al client.