/**
   * Tests that a job is properly canceled in the event of a leader change. However, this time only
   * the TMs are notified about the changing leader. This should be enough to cancel the currently
   * running job, though.
   */
  @Test
  public void testStateCleanupAfterListenerNotification() throws Exception {
    UUID leaderSessionID = UUID.randomUUID();
    UUID newLeaderSessionID = UUID.randomUUID();

    cluster.grantLeadership(0, leaderSessionID);
    cluster.notifyRetrievalListeners(0, leaderSessionID);

    cluster.waitForTaskManagersToBeRegistered();

    // submit blocking job
    cluster.submitJobDetached(job);

    ActorGateway jm = cluster.getLeaderGateway(timeout);

    Future<Object> wait =
        jm.ask(new WaitForAllVerticesToBeRunningOrFinished(job.getJobID()), timeout);

    Await.ready(wait, timeout);

    Future<Object> jobRemoval = jm.ask(new NotifyWhenJobRemoved(job.getJobID()), timeout);

    // notify listeners (TMs) about the leader change
    cluster.notifyRetrievalListeners(1, newLeaderSessionID);

    Await.ready(jobRemoval, timeout);
  }
  /**
   * Tests that a job is properly canceled in the case of a leader change. However, this time only
   * the JMs are notified about the leader change and the TMs still believe the old leader to have
   * leadership.
   */
  @Test
  public void testStateCleanupAfterNewLeaderElection() throws Exception {
    UUID leaderSessionID = UUID.randomUUID();
    UUID newLeaderSessionID = UUID.randomUUID();

    cluster.grantLeadership(0, leaderSessionID);
    cluster.notifyRetrievalListeners(0, leaderSessionID);

    cluster.waitForTaskManagersToBeRegistered();

    // submit blocking job so that we can test job clean up
    cluster.submitJobDetached(job);

    ActorGateway jm = cluster.getLeaderGateway(timeout);

    Future<Object> wait =
        jm.ask(new WaitForAllVerticesToBeRunningOrFinished(job.getJobID()), timeout);

    Await.ready(wait, timeout);

    Future<Object> jobRemoval = jm.ask(new NotifyWhenJobRemoved(job.getJobID()), timeout);

    // only notify the JMs about the new leader JM(1)
    cluster.grantLeadership(1, newLeaderSessionID);

    // job should be removed anyway
    Await.ready(jobRemoval, timeout);
  }
示例#3
0
 @Test
 public void blockMustBeCallable() throws Exception {
   Promise<String> p = Futures.promise();
   Duration d = Duration.create(1, TimeUnit.SECONDS);
   p.success("foo");
   Await.ready(p.future(), d);
   assertEquals(Await.result(p.future(), d), "foo");
 }
示例#4
0
 @Test
 public void mapToMustBeCallable() throws Exception {
   Promise<Object> p = Futures.promise();
   Future<String> f = p.future().mapTo(classTag(String.class));
   Duration d = Duration.create(1, TimeUnit.SECONDS);
   p.success("foo");
   Await.ready(p.future(), d);
   assertEquals(Await.result(p.future(), d), "foo");
 }
  @Test
  public void testFindPrimaryShardAsyncLocalPrimaryFound() throws Exception {

    TestActorRef<MessageCollectorActor> shardManager =
        TestActorRef.create(getSystem(), Props.create(MessageCollectorActor.class));

    DatastoreContext dataStoreContext =
        DatastoreContext.newBuilder()
            .dataStoreType("config")
            .shardLeaderElectionTimeout(100, TimeUnit.MILLISECONDS)
            .build();

    final DataTree mockDataTree = Mockito.mock(DataTree.class);
    final String expPrimaryPath = "akka://test-system/find-primary-shard";
    ActorContext actorContext =
        new ActorContext(
            getSystem(),
            shardManager,
            mock(ClusterWrapper.class),
            mock(Configuration.class),
            dataStoreContext,
            new PrimaryShardInfoFutureCache()) {
          @Override
          protected Future<Object> doAsk(ActorRef actorRef, Object message, Timeout timeout) {
            return Futures.successful(
                (Object) new LocalPrimaryShardFound(expPrimaryPath, mockDataTree));
          }
        };

    Future<PrimaryShardInfo> foobar = actorContext.findPrimaryShardAsync("foobar");
    PrimaryShardInfo actual = Await.result(foobar, Duration.apply(5000, TimeUnit.MILLISECONDS));

    assertNotNull(actual);
    assertEquals("LocalShardDataTree present", true, actual.getLocalShardDataTree().isPresent());
    assertSame("LocalShardDataTree", mockDataTree, actual.getLocalShardDataTree().get());
    assertTrue(
        "Unexpected PrimaryShardActor path " + actual.getPrimaryShardActor().path(),
        expPrimaryPath.endsWith(actual.getPrimaryShardActor().pathString()));
    assertEquals(
        "getPrimaryShardVersion",
        DataStoreVersions.CURRENT_VERSION,
        actual.getPrimaryShardVersion());

    Future<PrimaryShardInfo> cached =
        actorContext.getPrimaryShardInfoCache().getIfPresent("foobar");

    PrimaryShardInfo cachedInfo =
        Await.result(cached, FiniteDuration.apply(1, TimeUnit.MILLISECONDS));

    assertEquals(cachedInfo, actual);

    actorContext.getPrimaryShardInfoCache().remove("foobar");

    cached = actorContext.getPrimaryShardInfoCache().getIfPresent("foobar");

    assertNull(cached);
  }
示例#6
0
  @Test
  public void sendAndSendOffAndReadAwait() throws Exception {
    Agent<Integer> agent = Agent.create(5, ec);

    // #send
    // send a value, enqueues this change
    // of the value of the Agent
    agent.send(7);

    // send a Mapper, enqueues this change
    // to the value of the Agent
    agent.send(
        new Mapper<Integer, Integer>() {
          public Integer apply(Integer i) {
            return i * 2;
          }
        });
    // #send

    Mapper<Integer, Integer> longRunningOrBlockingFunction =
        new Mapper<Integer, Integer>() {
          public Integer apply(Integer i) {
            return i * 1;
          }
        };

    ExecutionContext theExecutionContextToExecuteItIn = ec;
    // #send-off
    // sendOff a function
    agent.sendOff(longRunningOrBlockingFunction, theExecutionContextToExecuteItIn);
    // #send-off

    assertEquals(Await.result(agent.future(), Duration.create(5, "s")), new Integer(14));
  }
示例#7
0
  @Test
  public void testTcpWorkerDupAndCancel() {
    ActorRef asyncWorker = null;
    logger.info("IN testTcpWorkerDupAndCancel");
    try {

      // Start new job

      int actorMaxOperationTimeoutSec = 15;
      asyncWorker =
          ActorConfig.createAndGetActorSystem()
              .actorOf(
                  Props.create(
                      TcpWorker.class, actorMaxOperationTimeoutSec, getTcpMetaSample(), LOCALHOST));

      final FiniteDuration duration = Duration.create(20, TimeUnit.SECONDS);
      Future<Object> future =
          Patterns.ask(asyncWorker, RequestWorkerMsgType.PROCESS_REQUEST, new Timeout(duration));
      // test dup
      asyncWorker.tell(RequestWorkerMsgType.PROCESS_REQUEST, asyncWorker);

      // test cancel
      asyncWorker.tell(RequestWorkerMsgType.CANCEL, asyncWorker);
      ResponseOnSingeRequest response = (ResponseOnSingeRequest) Await.result(future, duration);

      logger.info("\nWorker response:" + response.toString());

    } catch (Throwable ex) {

      logger.error("Exception in test : " + ex);
    }
  } // end func
示例#8
0
  @Test
  public void traverseForJavaApiMustWork() throws Exception {
    LinkedList<String> listStrings = new LinkedList<String>();
    LinkedList<String> expectedStrings = new LinkedList<String>();

    for (int i = 0; i < 10; i++) {
      expectedStrings.add("TEST");
      listStrings.add("test");
    }

    Future<Iterable<String>> result =
        Futures.traverse(
            listStrings,
            new Function<String, Future<String>>() {
              public Future<String> apply(final String r) {
                return Futures.future(
                    new Callable<String>() {
                      public String call() {
                        return r.toUpperCase();
                      }
                    },
                    system.dispatcher());
              }
            },
            system.dispatcher());

    assertEquals(Await.result(result, timeout), expectedStrings);
  }
示例#9
0
  @Test
  public void findForJavaApiMustWork() throws Exception {
    LinkedList<Future<Integer>> listFutures = new LinkedList<Future<Integer>>();
    for (int i = 0; i < 10; i++) {
      final Integer fi = i;
      listFutures.add(
          Futures.future(
              new Callable<Integer>() {
                public Integer call() {
                  return fi;
                }
              },
              system.dispatcher()));
    }
    final Integer expect = 5;
    Future<Option<Integer>> f =
        Futures.find(
            listFutures,
            new Function<Integer, Boolean>() {
              public Boolean apply(Integer i) {
                return i == 5;
              }
            },
            system.dispatcher());

    assertEquals(expect, Await.result(f, timeout).get());
  }
示例#10
0
  /**
   * Verifies a correct error message when vertices with master initialization (input formats /
   * output formats) fail.
   */
  @Test
  public void testFailureWhenInitializeOnMasterFails() {
    try {
      // create a simple job graph

      JobVertex jobVertex =
          new JobVertex("Vertex that fails in initializeOnMaster") {

            @Override
            public void initializeOnMaster(ClassLoader loader) throws Exception {
              throw new RuntimeException("test exception");
            }
          };

      jobVertex.setInvokableClass(Tasks.NoOpInvokable.class);
      JobGraph jg = new JobGraph("test job", jobVertex);

      // submit the job
      Future<Object> submitFuture =
          jmGateway.ask(
              new JobManagerMessages.SubmitJob(jg, ListeningBehaviour.EXECUTION_RESULT), timeout);
      try {
        Await.result(submitFuture, timeout);
      } catch (JobExecutionException e) {
        // that is what we expect
        // test that the exception nesting is not too deep
        assertTrue(e.getCause() instanceof RuntimeException);
      } catch (Exception e) {
        fail("Wrong exception type");
      }
    } catch (Exception e) {
      e.printStackTrace();
      fail(e.getMessage());
    }
  }
示例#11
0
 // Register a remote location where Restcomm will send monitoring updates
 protected Response registerForUpdates(
     final String accountSid, final MultivaluedMap<String, String> data, MediaType responseType) {
   try {
     secure(daos.getAccountsDao().getAccount(accountSid), "RestComm:Read:Calls");
   } catch (final AuthorizationException exception) {
     return status(UNAUTHORIZED).build();
   }
   // Get the list of live calls from Monitoring Service
   MonitoringServiceResponse liveCalls;
   try {
     final Timeout expires = new Timeout(Duration.create(60, TimeUnit.SECONDS));
     GetLiveCalls getLiveCalls = new GetLiveCalls();
     Future<Object> future = (Future<Object>) ask(monitoringService, getLiveCalls, expires);
     liveCalls =
         (MonitoringServiceResponse) Await.result(future, Duration.create(10, TimeUnit.SECONDS));
   } catch (Exception exception) {
     return status(BAD_REQUEST).entity(exception.getMessage()).build();
   }
   if (liveCalls != null) {
     if (APPLICATION_XML_TYPE == responseType) {
       final RestCommResponse response = new RestCommResponse(liveCalls);
       return ok(xstream.toXML(response), APPLICATION_XML).build();
     } else if (APPLICATION_JSON_TYPE == responseType) {
       Response response = ok(gson.toJson(liveCalls), APPLICATION_JSON).build();
       return response;
     } else {
       return null;
     }
   } else {
     return null;
   }
 }
  @Override
  protected void channelRead0(ChannelHandlerContext ctx, Routed routed) throws Exception {
    if (localJobManagerAddressFuture.isCompleted()) {
      if (localJobManagerAddress == null) {
        localJobManagerAddress = Await.result(localJobManagerAddressFuture, timeout);
      }

      Option<Tuple2<ActorGateway, Integer>> jobManager = retriever.getJobManagerGatewayAndWebPort();

      if (jobManager.isDefined()) {
        Tuple2<ActorGateway, Integer> gatewayPort = jobManager.get();
        String redirectAddress =
            HandlerRedirectUtils.getRedirectAddress(localJobManagerAddress, gatewayPort);

        if (redirectAddress != null) {
          HttpResponse redirect =
              HandlerRedirectUtils.getRedirectResponse(redirectAddress, routed.path());
          KeepAliveWrite.flush(ctx, routed.request(), redirect);
        } else {
          respondAsLeader(ctx, routed, gatewayPort._1());
        }
      } else {
        KeepAliveWrite.flush(ctx, routed.request(), HandlerRedirectUtils.getUnavailableResponse());
      }
    } else {
      KeepAliveWrite.flush(ctx, routed.request(), HandlerRedirectUtils.getUnavailableResponse());
    }
  }
  /**
   * Entry point. All recent finished azkaban jobs' lineage. Will write to database stagging table
   *
   * @param timeFrame in minutes
   * @param endTimeStamp in millisecond
   * @throws Exception
   */
  public void run(int timeFrame, long endTimeStamp) throws Exception {
    // get recent finished job
    AzJobChecker azJobChecker = new AzJobChecker(prop);
    List<AzkabanJobExecRecord> jobExecList =
        azJobChecker.getRecentFinishedJobFromFlow(timeFrame, endTimeStamp);
    azJobChecker.close();
    logger.info("Total number of azkaban jobs : {}", jobExecList.size());

    ActorSystem actorSystem = ActorSystem.create("LineageExtractor");
    int numOfActor = Integer.valueOf(prop.getProperty(Constant.LINEAGE_ACTOR_NUM, "50"));
    ActorRef lineageExtractorActor =
        actorSystem.actorOf(
            Props.create(AzLineageExtractorActor.class)
                .withRouter(new SmallestMailboxRouter(numOfActor)),
            "lineageExtractorActor");

    // initialize
    // AzkabanServiceCommunicator asc = new AzkabanServiceCommunicator(prop);
    HadoopNameNodeExtractor hnne = new HadoopNameNodeExtractor(prop);
    AzDbCommunicator adc = new AzDbCommunicator(prop);

    String wherehowsUrl = prop.getProperty(Constant.WH_DB_URL_KEY);
    String wherehowsUserName = prop.getProperty(Constant.WH_DB_USERNAME_KEY);
    String wherehowsPassWord = prop.getProperty(Constant.WH_DB_PASSWORD_KEY);
    String connUrl =
        wherehowsUrl + "?" + "user="******"&password="******"stg_job_execution_data_lineage");

    AzLogParser.initialize(conn);
    PathAnalyzer.initialize(conn);
    int timeout = 30; // default 30 minutes for one job
    if (prop.containsKey(Constant.LINEAGE_ACTOR_TIMEOUT_KEY))
      timeout = Integer.valueOf(prop.getProperty(Constant.LINEAGE_ACTOR_TIMEOUT_KEY));
    List<Future<Object>> result = new ArrayList<>();
    for (AzkabanJobExecRecord aje : jobExecList) {
      AzExecMessage message = new AzExecMessage(aje, prop);
      message.asc = null;
      message.hnne = hnne;
      message.adc = adc;
      message.databaseWriter = databaseWriter;
      message.connection = conn;
      Timeout t = new Timeout(timeout, TimeUnit.SECONDS);
      Future<Object> fut = Patterns.ask(lineageExtractorActor, message, t);
      result.add(fut);
    }

    // join all threads
    Future<Iterable<Object>> seq = Futures.sequence(result, actorSystem.dispatcher());
    try {
      Await.result(seq, Duration.create(timeout + " seconds"));
    } catch (TimeoutException exception) {
      exception.printStackTrace();
    }

    adc.close();
    hnne.close();
    databaseWriter.close();
    logger.info("All job finished lineage collecting!");
  }
 public void preStart() {
   try {
     System.out.println("=================================================");
     final Timeout timeout = new Timeout(Duration.create(1, SECONDS));
     Future<Object> rt =
         Patterns.ask(models.ChatRoom.defaultRoom, new Join(username, out), timeout);
     String result = (String) Await.result(rt, timeout.duration());
     System.out.println("-O-" + getSender());
     System.out.println("-O-" + getSelf());
     System.out.println("-O-" + getContext().self());
     System.out.println("-O-" + getContext().parent());
     if ("OK".equals(result)) {
       System.out.println("OK!");
       // go!
     } else {
       // Cannot connect, create a Json error.
       ObjectNode error = Json.newObject();
       error.put("error", result);
       // Send the error to the socket.
       out.tell(error, null);
       System.out.println("ERROR!");
       // getContext().parent().tell(PoisonPill.getInstance(), self());
       out.tell(PoisonPill.getInstance(), self());
     }
   } catch (Exception ex) {
     ex.printStackTrace();
     // force to stop actor
   }
 }
示例#15
0
  @Test
  public void reduceForJavaApiMustWork() throws Exception {
    LinkedList<Future<String>> listFutures = new LinkedList<Future<String>>();
    StringBuilder expected = new StringBuilder();

    for (int i = 0; i < 10; i++) {
      expected.append("test");
      listFutures.add(
          Futures.future(
              new Callable<String>() {
                public String call() {
                  return "test";
                }
              },
              system.dispatcher()));
    }

    Future<String> result =
        Futures.reduce(
            listFutures,
            new Function2<String, String, String>() {
              public String apply(String r, String t) {
                return r + t;
              }
            },
            system.dispatcher());

    assertEquals(Await.result(result, timeout), expected.toString());
  }
示例#16
0
  @Test
  public void alterAndAlterOff() throws Exception {
    Agent<Integer> agent = Agent.create(5, ec);

    // #alter
    // alter a value
    Future<Integer> f1 = agent.alter(7);

    // alter a function (Mapper)
    Future<Integer> f2 =
        agent.alter(
            new Mapper<Integer, Integer>() {
              public Integer apply(Integer i) {
                return i * 2;
              }
            });
    // #alter

    Mapper<Integer, Integer> longRunningOrBlockingFunction =
        new Mapper<Integer, Integer>() {
          public Integer apply(Integer i) {
            return i * 1;
          }
        };

    ExecutionContext theExecutionContextToExecuteItIn = ec;
    // #alter-off
    // alterOff a function (Mapper)
    Future<Integer> f3 =
        agent.alterOff(longRunningOrBlockingFunction, theExecutionContextToExecuteItIn);
    // #alter-off

    assertEquals(Await.result(f3, Duration.create(5, "s")), new Integer(14));
  }
  /**
   * Tests that a job is properly canceled in the case of a leader change. In such an event all
   * TaskManagers have to disconnect from the previous leader and connect to the newly elected
   * leader.
   */
  @Test
  public void testStateCleanupAfterNewLeaderElectionAndListenerNotification() throws Exception {
    UUID leaderSessionID1 = UUID.randomUUID();
    UUID leaderSessionID2 = UUID.randomUUID();

    // first make JM(0) the leader
    cluster.grantLeadership(0, leaderSessionID1);
    // notify all listeners
    cluster.notifyRetrievalListeners(0, leaderSessionID1);

    cluster.waitForTaskManagersToBeRegistered();

    // submit blocking job so that it is not finished when we cancel it
    cluster.submitJobDetached(job);

    ActorGateway jm = cluster.getLeaderGateway(timeout);

    Future<Object> wait =
        jm.ask(new WaitForAllVerticesToBeRunningOrFinished(job.getJobID()), timeout);

    Await.ready(wait, timeout);

    Future<Object> jobRemoval = jm.ask(new NotifyWhenJobRemoved(job.getJobID()), timeout);

    // make the JM(1) the new leader
    cluster.grantLeadership(1, leaderSessionID2);
    // notify all listeners about the event
    cluster.notifyRetrievalListeners(1, leaderSessionID2);

    Await.ready(jobRemoval, timeout);

    cluster.waitForTaskManagersToBeRegistered();

    ActorGateway jm2 = cluster.getLeaderGateway(timeout);

    Future<Object> futureNumberSlots =
        jm2.ask(JobManagerMessages.getRequestTotalNumberOfSlots(), timeout);

    // check that all TMs have registered at the new leader
    int numberSlots = (Integer) Await.result(futureNumberSlots, timeout);

    assertEquals(parallelism, numberSlots);

    // try to resubmit now the non-blocking job, it should complete successfully
    Tasks.BlockingOnceReceiver$.MODULE$.blocking_$eq(false);
    cluster.submitJobAndWait(job, false, timeout);
  }
  /**
   * Tests that the same JobManager can be reelected as the leader. Even though, the same JM is
   * elected as the next leader, all currently running jobs should be canceled properly and all TMs
   * should disconnect from the leader and then reconnect to it.
   */
  @Test
  public void testReelectionOfSameJobManager() throws Exception {
    UUID leaderSessionID = UUID.randomUUID();
    UUID newLeaderSessionID = UUID.randomUUID();

    FiniteDuration shortTimeout = new FiniteDuration(20, TimeUnit.SECONDS);

    cluster.grantLeadership(0, leaderSessionID);
    cluster.notifyRetrievalListeners(0, leaderSessionID);

    cluster.waitForTaskManagersToBeRegistered();

    // submit blocking job
    cluster.submitJobDetached(job);

    ActorGateway jm = cluster.getLeaderGateway(timeout);

    Future<Object> wait =
        jm.ask(new WaitForAllVerticesToBeRunningOrFinished(job.getJobID()), timeout);

    Await.ready(wait, timeout);

    Future<Object> jobRemoval = jm.ask(new NotifyWhenJobRemoved(job.getJobID()), timeout);

    // make JM(0) again the leader --> this implies first a leadership revokal
    cluster.grantLeadership(0, newLeaderSessionID);

    Await.ready(jobRemoval, timeout);

    // The TMs should not be able to reconnect since they don't know the current leader
    // session ID
    try {
      cluster.waitForTaskManagersToBeRegistered(shortTimeout);
      fail("TaskManager should not be able to register at JobManager.");
    } catch (TimeoutException e) {
      // expected exception since the TMs have still the old leader session ID
    }

    // notify the TMs about the new (old) leader
    cluster.notifyRetrievalListeners(0, newLeaderSessionID);

    cluster.waitForTaskManagersToBeRegistered();

    // try to resubmit now the non-blocking job, it should complete successfully
    Tasks.BlockingOnceReceiver$.MODULE$.blocking_$eq(false);
    cluster.submitJobAndWait(job, false, timeout);
  }
示例#19
0
  @Test
  public void testFailureWhenJarBlobsMissing() {
    try {
      // create a simple job graph
      JobVertex jobVertex = new JobVertex("Test Vertex");
      jobVertex.setInvokableClass(Tasks.NoOpInvokable.class);
      JobGraph jg = new JobGraph("test job", jobVertex);

      // request the blob port from the job manager
      Future<Object> future =
          jmGateway.ask(JobManagerMessages.getRequestBlobManagerPort(), timeout);
      int blobPort = (Integer) Await.result(future, timeout);

      // upload two dummy bytes and add their keys to the job graph as dependencies
      BlobKey key1, key2;
      BlobClient bc = new BlobClient(new InetSocketAddress("localhost", blobPort));
      try {
        key1 = bc.put(new byte[10]);
        key2 = bc.put(new byte[10]);

        // delete one of the blobs to make sure that the startup failed
        bc.delete(key2);
      } finally {
        bc.close();
      }

      jg.addBlob(key1);
      jg.addBlob(key2);

      // submit the job
      Future<Object> submitFuture =
          jmGateway.ask(
              new JobManagerMessages.SubmitJob(jg, ListeningBehaviour.EXECUTION_RESULT), timeout);
      try {
        Await.result(submitFuture, timeout);
      } catch (JobExecutionException e) {
        // that is what we expect
        assertTrue(e.getCause() instanceof IOException);
      } catch (Exception e) {
        fail("Wrong exception type");
      }
    } catch (Exception e) {
      e.printStackTrace();
      fail(e.getMessage());
    }
  }
示例#20
0
 @Test
 public void useWatch() throws Exception {
   ActorSystem system = ActorSystem.create("MySystem");
   ActorRef myActor = system.actorOf(new Props(WatchActor.class));
   Future<Object> future = Patterns.ask(myActor, "kill", 1000);
   assert Await.result(future, Duration.create("1 second")).equals("finished");
   system.shutdown();
 }
示例#21
0
 @Test
 public void useAsk() throws Exception {
   ActorRef testActor = system.actorOf(Props.create(JavaAPITestActor.class), "test");
   assertEquals(
       "Ask should return expected answer",
       JavaAPITestActor.ANSWER,
       Await.result(ask(testActor, "hey!", 3000), Duration.create(3, "seconds")));
 }
示例#22
0
 @Override
 public Topology.Host getHost(UUID hostId) {
   try {
     return Await.result(backend.store().get(Topology.Host.class, hostId), TIMEOUT);
   } catch (Exception e) {
     throw new RuntimeException("Failed to get host" + hostId);
   }
 }
 private void retrieveMessages(ActorSystem system) throws Exception {
   ActorRef service = getService(system);
   Timeout timeout = new Timeout(Duration.create(2, TimeUnit.SECONDS));
   Future<Object> fBets = Patterns.ask(service, new RetrieveBets(), timeout);
   List<Bet> bets = (List<Bet>) Await.result(fBets, timeout.duration());
   assert bets.size() == 200;
   System.out.println("*** TESTING OK");
 }
示例#24
0
 @Test
 public void useAskWithActorSelection() throws Exception {
   ActorRef testActor = system.actorOf(Props.create(JavaAPITestActor.class), "test2");
   ActorSelection selection = system.actorSelection("/user/test2");
   ActorIdentity id =
       (ActorIdentity)
           Await.result(ask(selection, new Identify("yo!"), 3000), Duration.create(3, "seconds"));
   assertEquals("Ask (Identify) should return the proper ActorIdentity", testActor, id.getRef());
 }
示例#25
0
  @Test
  public void createATypedActor() {
    try {
      // #typed-actor-create1
      Squarer mySquarer =
          TypedActor.get(system)
              .typedActorOf(new TypedProps<SquarerImpl>(Squarer.class, SquarerImpl.class));
      // #typed-actor-create1
      // #typed-actor-create2
      Squarer otherSquarer =
          TypedActor.get(system)
              .typedActorOf(
                  new TypedProps<SquarerImpl>(
                      Squarer.class,
                      new Creator<SquarerImpl>() {
                        public SquarerImpl create() {
                          return new SquarerImpl("foo");
                        }
                      }),
                  "name");
      // #typed-actor-create2

      // #typed-actor-calls
      // #typed-actor-call-oneway
      mySquarer.squareDontCare(10);
      // #typed-actor-call-oneway

      // #typed-actor-call-future
      Future<Integer> fSquare = mySquarer.square(10); // A Future[Int]
      // #typed-actor-call-future

      // #typed-actor-call-option
      Option<Integer> oSquare = mySquarer.squareNowPlease(10); // Option[Int]
      // #typed-actor-call-option

      // #typed-actor-call-strict
      int iSquare = mySquarer.squareNow(10); // Int
      // #typed-actor-call-strict
      // #typed-actor-calls

      assertEquals(100, Await.result(fSquare, Duration.create(3, TimeUnit.SECONDS)).intValue());

      assertEquals(100, oSquare.get().intValue());

      assertEquals(100, iSquare);

      // #typed-actor-stop
      TypedActor.get(system).stop(mySquarer);
      // #typed-actor-stop

      // #typed-actor-poisonpill
      TypedActor.get(system).poisonPill(otherSquarer);
      // #typed-actor-poisonpill
    } catch (Exception e) {
      // Ignore
    }
  }
 public Result index() throws Exception {
   if (system == null) {
     system = CarFactory.startCarFactory();
   }
   ActorRef actor = system.actorFor("akka://carfactory/user/dataFetcher");
   Timeout timeout = new Timeout(Duration.create(5000, "seconds"));
   Future<Object> ask = Patterns.ask(actor, new CountRequest(), timeout);
   Object result = Await.result(ask, timeout.duration());
   return ok(result.toString());
 }
示例#27
0
 @Test
 public void demonstrateAsk() throws Exception {
   // #test-behavior
   final Props props = Props.create(MyActor.class);
   final TestActorRef<MyActor> ref = TestActorRef.create(system, props, "testB");
   final Future<Object> future = akka.pattern.Patterns.ask(ref, "say42", 3000);
   assertTrue(future.isCompleted());
   assertEquals(42, Await.result(future, Duration.Zero()));
   // #test-behavior
 }
示例#28
0
 @Override
 public void setFloodingProxyWeight(UUID hostId, int weight) {
   try {
     Host h = Await.result(backend.store().get(Host.class, toProto(hostId)), TIMEOUT);
     h = h.toBuilder().setFloodingProxyWeight(weight).build();
     backend.store().update(h);
   } catch (Exception e) {
     throw new RuntimeException("Can't retrieve flooding proxy weight");
   }
 }
示例#29
0
 @Override
 public Integer getFloodingProxyWeight(UUID hostId) {
   try {
     return Await.result(backend.store().get(Host.class, toProto(hostId)), TIMEOUT)
         .getFloodingProxyWeight();
     // for backwards compatibility
   } catch (Exception e) {
     throw new RuntimeException("Can't retrieve flooding proxy weight");
   }
 }
 /* (non-Javadoc)
  * @see akka.actor.UntypedActor#onReceive(java.lang.Object)
  */
 @Override
 public void onReceive(Object message) throws Exception {
   // TODO Auto-generated method stub
   if (message instanceof RpcEvent.CallMethod) {
     Future<Object> future =
         Patterns.ask(rpc, message, new Timeout(Duration.create(10, TimeUnit.SECONDS)));
     Object o = Await.result(future, Duration.create(10, TimeUnit.SECONDS));
     getSender().tell(o, getSelf());
   }
 }