attori remoti Scala

Question

Esistono guide o tutorial che spiegano la possibilità di utilizzare gli attori di scala in remoto? Tutto quello che ho trovato fino ad ora è un esempio (senza commenti) ma questo è appena sufficiente.

Answer 1

Ho scritto un po 'di tempo fa an article with an example app to explain the use of Remote Actors.

Bene, non ha commenti all'interno del codice (forse intendevi anche quell'articolo), ma ci sono delle spiegazioni sotto il codice.

Answer 2

Nessuno dei quali sono a conoscenza. È praticamente un approccio di "hackerare la tua strada attraverso la giungla". A giudicare dall'API, tuttavia, le cose dovrebbero funzionare più o meno come gli attori normali, per i quali esistono uno o due tutorial (così come alcuni libri ora).

Se si fa ricorso a attori remoti, noi (la comunità) apprezzeremmo senz'altro questo tutorial da un utente esperto!

Answer 3

Basta fare attenzione a inviare messaggi serializzabili (classi caso e oggetto case!) E assicurarsi che il lato opposto possa creare la classe. Stai attento ai Classloader personalizzati o ai JAR mancanti nei tuoi classpath.

Answer 4

Il framework Akka ha remote actors. L'API è abbastanza simile ai normali attori di scala.

Forniscono anche un certo livello di cluster automatico, ma non è completo.

Answer 5

di recente vi era una guida aggiunto sulla prima pagina di www.scala-lang.org, ecco il link http://www.scala-lang.org/docu/files/actors-api/actors_api_guide.html#

Answer 6

Forse questo è un necropost ma ero alla ricerca di tutto e non poteva trovare molto . Speriamo che questo possa aiutare qualcuno.

Sono in esecuzione Mac OS 10.6.8 eScala 2.9.0.1. Ho avuto problemi nel far girare l'esempio degli attori remoti canonici. Ho finito con il seguente codice.

Nota: Il metodo chiaro è solo per evitare che i messaggi di accumulando. Non è fondamentale per l'esempio. Allo stesso modo, le chiamate a Thread.sleep servono solo per rendere più semplice la visualizzazione di ciò che accade in fase di esecuzione.

compila, allora in casi coperture separati fare:

$> scala Ping 

e

$> scala Pong 

in qualsiasi ordine. Puoi sperimentare uccidendo uno di essi alla volta e tracciando il codice.

import scala.actors._ 
import scala.actors.Actor._ 
import scala.actors.remote._ 
import scala.actors.remote.RemoteActor._ 

/** @author Connor Doyle */ 

// Remote messages must be serializable. 
// The easist way to do this is to wrap 
// them with a case class 
case class Message(text: String) 

abstract class PingPongActor extends Actor with App { 
    val pingPort = 9000 
    val pongPort = 9001 
    val delay = 1000 
    classLoader = getClass().getClassLoader() // hack! 
    start 

    // this method consumes all pending messages 
    // the library should have implemented an atomic 
    // receiveAndClear operation 
    def clear: Unit = receiveWithin(0) { 
     case TIMEOUT =>() 
     case _ => clear 
    } 
} 

object Ping extends PingPongActor { 

    // result of select already lazy, but explicit lazy conveys 
    // semantics clearly 
    lazy val pong = select(Node("localhost", pongPort), 'pong) 

    def act = { 
     alive(pingPort) 
     register('ping, self) 
     loop { 
      pong ! Message("ping") 
      receiveWithin(delay * 2) { 
       case Message(text: String) => { 
        clear 
        println("received: "+text) 
        Thread.sleep(delay) // wait a while 
       } 
       case TIMEOUT => println("ping: timed out!") 
      } 
     } 
    } 
} 

object Pong extends PingPongActor { 

    lazy val ping = select(Node("localhost", pingPort), 'ping) 

    def act = { 
     alive(pongPort) 
     register('pong, self) 
     loop { 
      receiveWithin(delay * 2) { 
       case Message(text: String) => { 
        println("received: "+text) 
        Thread.sleep(delay) // wait a while 
        clear 
        ping ! Message("pong") 
       } 
       case TIMEOUT => println("pong: timed out") 
      } 
     } 
    } 
} 

Cheers!