Comment déconnecter un Scala Remote Actor?

Question

Dans Scala, il est très facile de se connecter à un acteur distant, mais la documentation ne me dit rien sur la déconnexion. Le simple fait de jeter la référence ne fonctionne pas, car les acteurs distants sont des acteurs, donc ceux-ci ne seront pas collectés avant d'être stoppés. Alors, comment me déconnecter?

Cela ne Terminate après la sortie:

import actors.{DaemonActor,remote} 
import remote.{RemoteActor,Node} 

object SimpleClient{ 
    val messageHandler = new DaemonActor{ 
     def act{ 
      loop{ 
       react{ 
        case message:String => 
         println("got message: " + message) 
        case _ => 
       } 
      } 
     } 
     start 
    } 

    def main(args:Array[String]){ 
     val server = RemoteActor.select(Node("localhost",9999),'server) 
     server.send('Connect,messageHandler) 

     var exit = false 
     while(!exit){ 
      val message = Console.readLine 
      if(message == "exit" || message == "quit") { 
       exit = true 
       server ! 'Disconnect 
      } 
      else 
       server ! message 
     } 
    } 
} 

Ce serveur:

import actors.{Actor,OutputChannel} 
import actors.remote.RemoteActor 

object Server extends Actor{ 
    val clients = new collection.mutable.HashSet[OutputChannel[Any]] 
    def act{ 
     loop{ 
      react{ 
       case 'Connect => 
        clients += sender 
       case 'Disconnect => 
        clients -= sender 
       case message:String => 
        for(client <- clients) 
         client ! message 
      } 
     } 
    } 

    def main(args:Array[String]){ 
     start 
     RemoteActor.alive(9999) 
     RemoteActor.register('server,this) 
    } 
} 

Answer 1

Voici une version de travail de la source, avec des changements pertinents commenté en ligne:

import actors.{DaemonActor,remote} 
import remote.{RemoteActor,Node} 

case class Send(message: String) 
case object Disconnect 

object SimpleClient{ 
    val messageHandler = new DaemonActor{ 

     def act{ 
      // keep the reference to the proxy inside the client-side actor 
      val server = RemoteActor.select(Node("localhost",9999),'server) 
      server ! 'Connect 
      loop{ 
      react{ 
       case message:String => 
        println("got message: " + message) 
       case Send(message) => server ! message 
       case Disconnect => { 
        // disconnect and exit the client-side actor 
        server ! 'Disconnect //' 
        exit 
       } 
       case _ => 
       } 
      } 
     } 
     start 
    } 

    def main(args:Array[String]){ 
     var exit = false 
     while(!exit){ 
     val message = Console.readLine 
     if(message == "exit" || message == "quit") { 
      exit = true 
      // tell the client-side actor to exit 
      messageHandler ! Disconnect 
     } else { 
      messageHandler ! Send(message) 
     } 
     } 
    } 
} 

Answer 2

Votre question est vraiment pas assez clair sur ce problème que vous pensez que vous rencontrez. Acteurs font pas "se connecter" les uns aux autres (comme une socket). Vous envoyez un message à un acteur parce que vous avez une référence à celui-ci (ou un proxy, dans le cas des acteurs distants).

Avoir une telle référence n'empêche pas l'acteur (l'un ou l'autre acteur) de s'arrêter. S'il n'y a plus de références à un acteur et qu'il n'est pas en cours d'exécution, rien ne l'empêche d'être récupéré par les ordures

Answer 3

Le trait Reactor définit protected[actors] def exit(): Nothing que l'acteur peut appeler lui-même à la réception d'un message lui indiquant de faire alors.

sealed trait Msg 
case object Apoptosis extends Msg 
// ... more messages 


class RRActor extends Reactor[Msg] { 
    def act = loop { 
    react { 
     // ... Whatever messages the actor handles 
     case Apoptosis => this.exit 
    } 
    } 
} 

Edit: Je n'ai jamais testé cela avec des acteurs distants.

Answer 4

[Disclaimer: Je suis PO d'Akka]

je suggère de jeter un oeil à Akka, qui a été construit avec les acteurs à distance à l'esprit du jour 1? www.akka.io