scala - akka become

Actores remotos Scala

Question

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

Answer 1

Ninguno de los cuales soy consciente. 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 tal tutorial a un usuario experimentado.

Answer 2

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 3

El marco Akka tiene actores remotos . La API es bastante similar a los actores Scala regulares.

También proporcionan cierto nivel de agrupamiento automático, pero no está completo.

Answer 4

Recientemente, se agregó una guía en la página principal de www.scala-lang.org, aquí está el enlace http://www.scala-lang.org/docu/files/actors-api/actors_api_guide.html#

Answer 5

He escrito un artículo con una aplicación de ejemplo para explicar el uso de Remote Acctors hace un tiempo.

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

Answer 6

Quizás esto es un necropost pero estaba buscando por todos lados y no pude 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étodo claro es solo para evitar que los mensajes se acumulen. No es crítico para el ejemplo. Del mismo modo, las llamadas a Thread.sleep son solo para que sea más fácil ver lo que está sucediendo en el tiempo de ejecución.

Compílalo, luego en instancias de shell separadas hazlo:

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

¡Aclamaciones!