Je veux créer un simple cluster singleton et envoyer un message à partir d'un nœud distant

Question

Ici, j'ai créé un acteur singleton. Le maître et le nœud de départ sont les mêmes. D'un projet différent j'essaye d'ajouter dans le groupe et veux envoyer le message. Je suis capable de rejoindre le cluster mais je ne peux pas envoyer de message.

Mon nœud maître et de semences:

 package Demo 
    import akka.actor._ 
    import akka.cluster.singleton.{ClusterSingletonManager, ClusterSingletonManagerSettings, ClusterSingletonProxy, ClusterSingletonProxySettings} 
    import com.typesafe.config.ConfigFactory 
    import scala.concurrent.duration._ 
    object MainObject1 extends App{ 
    DemoMain1.start(8888) 

    } 
    object DemoMain1 { 
     val role = "test" 
     val singletonname = "Ruuner" 
     val mastername = "Master" 
     def start(port: Int): ActorSystem = { 
     val conf = ConfigFactory.parseString(
      s""" 
    |akka.actor.provider = "akka.cluster.ClusterActorRefProvider" 
    | 
    |akka.remote.netty.tcp.port = $port 
    |akka.remote.netty.tcp.hostname = 127.0.0.1 
    |akka.cluster.roles = ["$role"] 
    |akka.cluster.seed-nodes = ["akka.tcp://DemoMain1@127.0.0.1:8888"] 

    """.stripMargin 
) 
val system = ActorSystem("DemoMain1", conf) 
val settings = ClusterSingletonManagerSettings(system).withRole(role) 
val manager = ClusterSingletonManager.props(Props[DemoMain1], PoisonPill, settings) 
val actor=system.actorOf(manager, mastername) 
system 
     } 

     class DemoMain1 extends Actor with Identification { 
     import context._ 
     override def preStart(): Unit = { 
      println(s"Master is created with id $id in $system") 
      println(self.path.address.host) 
      system.scheduler.scheduleOnce(100.seconds, self, 'exit) 

     } 

     override def receive : Receive={ 
    case 'exit => println("$id is exiting") 
    context stop self 
    //SupervisorStrategy.Restart 


    case msg => println(s"messasge from $system is $msg ") 

     sender() ! 'how 
     } 
     } 
    } 

L'autre nœud qui tente de rejoindre le cluster et envoyer un message.

 import akka.actor._ 
    import akka.cluster.singleton.{ClusterSingletonProxy, ClusterSingletonProxySettings} 
    import com.typesafe.config.ConfigFactory 
    import scala.concurrent.duration._ 
    object Ping extends App{ 
     def ping: ActorSystem = { 
     val conf = ConfigFactory.parseString(
      s""" 
       |akka.actor.provider = "akka.cluster.ClusterActorRefProvider" 
    | 
    |akka.remote.netty.tcp.port = 0 
    |akka.remote.netty.tcp.hostname = 127.0.0.1 
    |akka.cluster.roles = ["slave"] 
    |akka.cluster.seed-nodes = ["akka.tcp://DemoMain1@127.0.0.1:8888"] 
    |akka.cluster.auto-down-unreachable-after = 10s 
    """.stripMargin 
) 
val system = ActorSystem("DemoMain1", conf) 
system.actorOf(Props[Ping]) 
system 
     } 
     class Ping extends Actor { 
     import context._ 
     val path = "akka.tcp://DemoMain1@127.0.0.1:8888/DemoMain1/user/Master/actor" 
     val settings = ClusterSingletonProxySettings(system).withRole("slave") 
     val actor = context.actorOf(ClusterSingletonProxy.props(path, settings)) 
     val pingInterval = 1.seconds 
     override def preStart(): Unit = { 
      system.scheduler.schedule(pingInterval, pingInterval) { 
      println(s"Locate Ping $system") 
      actor ! 'hi 
      } 
     } 

     override def receive: Receive = { 
      case msg => println(s"The message is $msg") 

     } 
     } 
     Ping.ping 
    } 

Si je donne des adresses IP du système, puis aussi le message n'a pas été envoyé.

Answer 1

Il semble que le role dans vos ClusterSingletonProxySettings(system).withRole("slave") paramètres de votre acteur Ping ne correspond pas à celle de votre ClusterSingletonManagerSettings(system).withRole(role) où role = "test".

ClusterSingletonProxy est censé être présent sur tous les noeuds avec spécifié role sur lequel le groupe est mis en place, d'où ses paramètres doivent correspondre roleClusterSingletonManager « s. Voici un sample configuration.