Scala remote actors

Question

¿Hay guías o tutoriales que expliquen la posibilidad de utilizar scala actors de forma remota? Todo lo que he encontrado hasta ahora es un ejemplo (sin comentarios) pero eso no es suficiente.

Answer 1

He escrito an article with an example app to explain the use of Remote Actors hace un tiempo.

Bueno, no tiene comentarios dentro del código (tal vez incluso quiso decir ese artículo), pero hay explicaciones debajo del código.

Answer 2

Ninguno de los que tengo conocimiento. Es más o menos un enfoque de "atraviesa la jungla". Sin embargo, a juzgar por la API, las cosas deberían funcionar más o menos igual que los actores regulares, para lo cual existen uno o dos tutoriales (así como algunos libros ahora).

Si utiliza actores remotos, ¡nosotros (la comunidad) sin duda daríamos la bienvenida a este tipo de tutoriales a un usuario experimentado!

Answer 3

Solo tenga cuidado de enviar mensajes que sean serializables (¡las clases de casos y los objetos son!) Y asegúrese de que el lado opuesto pueda crear la clase. Tenga cuidado con ClassLoaders personalizados o JAR faltantes en sus classpaths.

Answer 4

El marco de Akka tiene remote actors. La API es bastante similar a los actores Scala regulares.

Proporcionan cierto nivel de agrupamiento automático también, pero no está completo.

Answer 5

hace poco no existía una guía añadido en la primera página de www.scala-lang.org, aquí está el enlace http://www.scala-lang.org/docu/files/actors-api/actors_api_guide.html#

Answer 6

Tal vez este es un necropost pero yo estaba buscando por todas partes y no podía encontrar mucho . Espero que esto ayude a alguien.

Estoy ejecutando Mac OS 10.6.8 y Scala 2.9.0.1. Tuve problemas para ejecutar el ejemplo canónico de actores remotos. Terminé con el siguiente código.

Nota: El métodoclara es sólo para evitar que los mensajes se acumulen. No es crítico para el ejemplo. Del mismo modo, las llamadas a Thread.sleep son simplemente para que sea más fácil ver lo que está sucediendo en el tiempo de ejecución.

compilarlo, a continuación, en los casos de concha separadas hacen:

$> scala Ping 

y

$> scala Pong 

en cualquier orden. Puedes experimentar matando a uno de ellos a la vez y rastreando el código.

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

¡Salud!