Package akka.actor

Examples of akka.actor.ActorRef


    public static void main(String[] args) {
        // Create the 'helloakka' actor system
        final ActorSystem system = ActorSystem.create("helloakka");

        // Create the 'greeter' actor
        final ActorRef greeter = system.actorOf(Props.create(Greeter.class), "greeter");

        // Create the "actor-in-a-box"
        final Inbox inbox = Inbox.create(system);

        // Tell the 'greeter' to change its 'greeting' message
        greeter.tell(new WhoToGreet("akka"), ActorRef.noSender());

        // Ask the 'greeter for the latest 'greeting'
        // Reply should go to the "actor-in-a-box"
        inbox.send(greeter, new Greet());

        // Wait 5 seconds for the reply with the 'greeting' message
        Greeting greeting1 = (Greeting) inbox.receive(Duration.create(5, TimeUnit.SECONDS));
        System.out.println("Greeting: " + greeting1.message);

        // Change the greeting and ask for it again
        greeter.tell(new WhoToGreet("typesafe"), ActorRef.noSender());
        inbox.send(greeter, new Greet());
        Greeting greeting2 = (Greeting) inbox.receive(Duration.create(5, TimeUnit.SECONDS));
        System.out.println("Greeting: " + greeting2.message);

        // after zero seconds, send a Greet message every second to the greeter with a sender of the GreetPrinter
        ActorRef greetPrinter = system.actorOf(Props.create(GreetPrinter.class));
        system.scheduler().schedule(Duration.Zero(), Duration.create(1, TimeUnit.SECONDS), greeter, new Greet(), system.dispatcher(), greetPrinter);
        //system.shutdown();
    }
View Full Code Here


    // Create an Akka system
    ActorSystem system = ActorSystem.create("PiSystem");

    // create the result listener, which will print the result and shutdown
    // the system
    final ActorRef listener = system.actorOf(new Props(Listener.class),
        "listener");

    // create the master
    ActorRef master = system.actorOf(new Props(new UntypedActorFactory() {
      private static final long serialVersionUID = 1L;

      public UntypedActor create() {
        return new Master(nrOfWorkers, nrOfMessages, nrOfElements,
            listener);
      }
    }), "master");

    // start the calculation
    master.tell(new Calculate());

  }
View Full Code Here

    @SuppressWarnings({ "rawtypes", "unchecked" })
  public static void main(String... args) {
        ActorSystem system = ActorSystem.create("example");

        ActorRef counter = system.actorOf(new Props(Counter.class));

        counter.tell("tick");
        counter.tell("tick");
        counter.tell("tick");

        Future future = ask(counter, "get", 5000);

        future.onSuccess(new OnSuccess<Integer>() {
            public void onSuccess(Integer count) {
View Full Code Here

        super();
    }

    @Test
    public void testCreateOperation() throws Exception {
        ActorRef ref = createActorRef();
        ref.tell(getClass());

        Thread.sleep(1000);

        Operation operation = getLastEntered();
        Operation expected = new Operation().type(AkkaDefinitions.OperationTypes.AKKA_OP_UNTYPED_ACTOR)
View Full Code Here

  /**
   * @param args
   */
  public static void main(String[] args) {
    ActorRef actor = actorOf(new UntypedActorFactory() {
      public UntypedActor create() {
        return new WCMapReduceApp(10,
            "/Users/brlee/Workspace/WordCountFiles", 3);
      }
    });
    actor.start();
    actor.sendOneWay(new StartWork());
  }
View Full Code Here

*/
public class FaultToleranceApp extends BaseRootSupervisorImpl
{
    public static void main( String[] args )
    {
        ActorRef master = actorOf(FaultToleranceApp.class);
        master.sendOneWay(new StartWork());
    }
View Full Code Here

    public static WebSocket<JsonNode> ws() {
        return new WebSocket<JsonNode>() {
            public void onReady(final WebSocket.In<JsonNode> in, final WebSocket.Out<JsonNode> out) {
                // create a new UserActor and give it the default stocks to watch
                final ActorRef userActor = Akka.system().actorOf(Props.create(UserActor.class, out));
               
                // send all WebSocket message to the UserActor
                in.onMessage(new F.Callback<JsonNode>() {
                    @Override
                    public void invoke(JsonNode jsonNode) throws Throwable {
View Full Code Here

    /**
     * @author chunyang
     * Create Managers locally or remotely
     */
   
    ActorRef agentCommandManager = null;
   
    if (localMode || nodeList.size()==0) {
      agentCommandManager =  system.actorOf(
          Props.create(LocalManager.class),"AgentCommandManager-" + UUID.randomUUID().toString()
        );
      jobQ.offer(managerList.size());
      managerList.add(agentCommandManager);
      localMode = true;
    }
    else {
      for (Address m : nodeList) {
        agentCommandManager = system.actorOf(
          Props.create(LocalManager.class).withDeploy(
              new Deploy(
                   new RemoteScope(
                      m
                      )
                  )),
          "AgentCommandManager-" + UUID.randomUUID().toString()
        );
       
        jobQ.offer(managerList.size());
        managerList.add(agentCommandManager);
        ClusterState.memberLoad.get(m).addAndGet(maxConcNum);
      }
    }
   
    /**
     * Dispatch Jobs
     * @author chunyang
     */
    if (!localMode) {
      List<Map<String, NodeData>> jobGroupList = partDataStore(nodeDataMapValidSafe, nodeList.size()==0?
          totJobNum:Math.min(totJobNum/nodeList.size()+1, 1000));
      List<ActorRef> dispatcherList = new ArrayList<ActorRef>();
      int requestChunckSize = jobGroupList.size()/managerList.size() + 1; // Last one do less
     
      for (int i=0; i<Math.min(3, managerList.size()) ; i++) {
        dispatcherList.add(
            system.actorOf(
                Props.create(JobDispatcher.class, managerList, jobGroupList, jobQ, requestChunckSize,
                    nodeGroupType, agentCommandType, directorJobUuid, maxConcNum)
                )
            );
      }
     
      for (ActorRef dispatcher : dispatcherList) {
        dispatcher.tell("start dispatching", null);
      }
    } else {
      Map<String, NodeGroupDataMap> totDataStore = new HashMap<String, NodeGroupDataMap>();
      totDataStore.put(nodeGroupType, new NodeGroupDataMap(nodeGroupType));
      totDataStore.get(nodeGroupType).setNodeDataMapValid(nodeDataMapValidSafe);
      Future<Object> ackFuture = Patterns.ask(managerList.get(0), new InitialRequestToManager(nodeGroupType,
          agentCommandType, directorJobUuid, totDataStore, true, false, maxConcNum), new Timeout(Duration.create(
              15, TimeUnit.SECONDS)));
      try {
        Await.result(ackFuture,  Duration.create(
            15, TimeUnit.SECONDS));
      } catch (Exception e) {
        // TODO Auto-generated catch block
        e.printStackTrace();
      }
      managerList.get(0).tell(new endOfRequest(), null);
    }
   
    ActorRef monitor = system.actorOf(Props.create(Monitor.class, managerList, directorJobUuid, jobStatus), "ProgressMonitor" + directorJobUuid);
   
    ActorRef collector = system.actorOf(Props.create(ResponseCollector.class, jobInfo), "ResultCollector" + directorJobUuid);
   
    final FiniteDuration gatherResponseDuration = Duration.create(
        3600, TimeUnit.SECONDS);
   
    /**
     * Gather Result.
     */
    Future<Object> totResponse = Patterns.ask(collector, new gatherResponse(monitor, totJobNum), new Timeout(gatherResponseDuration));
   
    BatchResponseFromManager responseFromCollecter = null;
    try {
      responseFromCollecter = (BatchResponseFromManager) Await.result(totResponse, gatherResponseDuration);
      System.out.println("Gather Result Back! : " + responseFromCollecter.responseMap.size());
      /**
       * Slave Fail Over
       */
      int failCount = 3;
      while (responseFromCollecter.responseMap.size() < totJobNum && failCount >= 0) {
        System.out.println("Response less than request, fail over @@");
        failCount -- ;
        Map<String, NodeData> failOverMap = gatherFailOverData(nodeDataMapValidSafe, responseFromCollecter);
       
        List<Address> failOverNodeList = new ArrayList<Address>();
       
        int failOverTot = failOverMap.size();
       
        for (Address m : nodeList) {
          if (ClusterState.memberLoad.containsKey(m)) {
            failOverNodeList.add(m);
            failOverTot -= 2000;
            if (failOverTot < 0)
              break;
          }
        } 
       
       
        List<ActorRef> failOverManagerList = new ArrayList<ActorRef>();
        Queue<Integer> failOverJobQ = new ConcurrentLinkedQueue<Integer>();
       
        if (localMode || failOverNodeList.size()==0) {
          agentCommandManager =  system.actorOf(
              Props.create(LocalManager.class),"AgentCommandManager-" + UUID.randomUUID().toString()
            );
          failOverJobQ.offer(failOverManagerList.size());
          failOverManagerList.add(agentCommandManager);
          managerList.add(agentCommandManager);
          localMode = true;
        }
        else {
          for (Address m : failOverNodeList) {
            agentCommandManager = system.actorOf(
              Props.create(LocalManager.class).withDeploy(
                  new Deploy(
                       new RemoteScope(
                          m
                          )
                      )),
              "AgentCommandManager-" + UUID.randomUUID().toString()
            );
           
            failOverJobQ.offer(failOverManagerList.size());
            failOverManagerList.add(agentCommandManager);
            managerList.add(agentCommandManager);
          }
        }
        if (!localMode) {
          List<Map<String, NodeData>> failOverJobGroupList = partDataStore(failOverMap, failOverNodeList.size()==0?
              failOverMap.size():Math.min(failOverMap.size()/failOverNodeList.size()+1, 1000));
          List<ActorRef> failOverDispatcherList = new ArrayList<ActorRef>();
          int failOverRequestChunckSize = failOverJobGroupList.size()/failOverManagerList.size() + 1; // Last one do less
         
          for (int i=0; i<Math.min(3, failOverManagerList.size()) ; i++) {
            failOverDispatcherList.add(
                system.actorOf(
                    Props.create(JobDispatcher.class, failOverManagerList, failOverJobGroupList, failOverJobQ, failOverRequestChunckSize,
                        nodeGroupType, agentCommandType, directorJobUuid, maxConcNum)
                    )
                );
          }
         
          for (ActorRef failOverDispatcher : failOverDispatcherList) {
            failOverDispatcher.tell("start dispatching", null);
          }
        } else {
          Map<String, NodeGroupDataMap> failOverDataStore = new HashMap<String, NodeGroupDataMap>();
          failOverDataStore.put(nodeGroupType, new NodeGroupDataMap(nodeGroupType));
          failOverDataStore.get(nodeGroupType).setNodeDataMapValid(failOverMap);
          Future<Object> ackFuture = Patterns.ask(failOverManagerList.get(0), new InitialRequestToManager(nodeGroupType,
              agentCommandType, directorJobUuid, failOverDataStore, true, false, maxConcNum), new Timeout(Duration.create(
                  15, TimeUnit.SECONDS)));
          try {
            Await.result(ackFuture,  Duration.create(
                15, TimeUnit.SECONDS));
          } catch (Exception e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
          }
          failOverManagerList.get(0).tell(new endOfRequest(), null);
        }
       
        jobInfo.state = State.processing;
       
       
        Future<Object> futureFailOverResponse = Patterns.ask(collector, new gatherResponse(monitor, totJobNum), new Timeout(gatherResponseDuration));
        BatchResponseFromManager failOverResponse = (BatchResponseFromManager) Await.result(futureFailOverResponse, gatherResponseDuration);
        System.out.println("FailOver Result Size" + failOverResponse.responseMap.size());
        for (Entry<String, GenericAgentResponse> e : failOverResponse.responseMap.entrySet()) {
          responseFromCollecter.responseMap.put(e.getKey(), e.getValue());
        }
      }
     
      for (Entry<String, GenericAgentResponse> e: responseFromCollecter.getResponseMap().entrySet()) {
        AgentDataProviderHelper.getInstance()
        .updateResponseFromAgentGenericResponse(nodeGroupType,
            agentCommandType, e.getValue(), dataStore);
      }
    } catch (Exception e) {
      System.out.println("Response Collector Timeout");
      responseFromCollecter = new BatchResponseFromManager();
    }
   
    jobInfo.endTime = System.currentTimeMillis();
    jobInfo.aggregationTime = (jobInfo.endTime - jobInfo.finishedNotAggregatedTime)/1000.0;
    jobInfo.state = State.gathered;
   
    System.out.println("Clear actors.");
   
    system.stop(monitor);
    system.stop(collector);
   
    for (ActorRef m : managerList) {
      system.stop(m);
    }
   
    if (localMode || nodeList.size() ==0 )
      localLoad.addAndGet( -maxConcNum);
   
    for (Address m : nodeList) {
      if (ClusterState.memberLoad.containsKey(m))
        ClusterState.memberLoad.get(m).addAndGet(-maxConcNum);
    }
   
    final FiniteDuration durationLogWorker = Duration.create(
        VarUtils.TIMEOUT_ASK_LOGWORKER_SCONDS, TimeUnit.SECONDS);
   
    ActorRef logWorker = ActorConfig.getActorSystem().actorOf(
        Props.create(LogWorker.class,
            nodeGroupType, agentCommandType, dataStore, directorJobUuid),
        "LogWorker-" + UUID.randomUUID().toString()
      );
     
View Full Code Here

  public void onReceive(Object message) {
    if (message instanceof String) {
      Integer index = jobQ.poll();
      while (index != null) {
        System.out.println("Poll Job: " + index);
        ActorRef manager = managerList.get(index);
        streamSendRequest(manager, index);
        index = jobQ.poll();
      }
      getContext().stop(getSelf());
    }
View Full Code Here

    }
  }
 
  private BatchResponseFromManager streamResponse() {
    BatchResponseFromManager response = new BatchResponseFromManager();
    ActorRef manager = slaveQ.poll();
    while (manager != null) {
      FiniteDuration duration = Duration.create(
          60, TimeUnit.SECONDS);
      streamRequestToManager streamRequest = new streamRequestToManager(0);
      Future<Object> futureResponse = Patterns.ask(manager, streamRequest, new Timeout(duration));
      System.out.println(manager.path().address().toString());
     
      try {
        BatchResponseFromManager partResponse = (BatchResponseFromManager) Await.result(futureResponse, duration);
        while (partResponse.getResponseMap().size() > 0) {
          collectResult(response, partResponse);
View Full Code Here

TOP

Related Classes of akka.actor.ActorRef

Copyright © 2018 www.massapicom. All rights reserved.
All source code are property of their respective owners. Java is a trademark of Sun Microsystems, Inc and owned by ORACLE Inc. Contact coftware#gmail.com.