private ActorRef getOrCreateLogActor(String name) { ActorRef logActor = logsSessions.get(name); if (logActor == null) { logActor = context().actorOf( Props.create(new ApplicationLogActor.ActorCreator(context, appToken)) .withDispatcher(LOG_DISPATCHER_NAME) ); context().watch(logActor); logsSessions.put(logActor.path().name(), logActor); } return logActor; }
if (endpointHash != null) { LocalEndpointActorMetaData actorMetaData = localEndpointSessions.get(endpointHash); if (actorMetaData != null && actorMetaData.actorRef.equals(localActor)) { localEndpointSessions.remove(endpointHash); LOG.debug("[{}] removed endpoint: {}", appToken, localActor);
new JavaTestKit(system) {{ final Deadline deadline = new FiniteDuration(3, TimeUnit.MINUTES).fromNow(); leader1 = system.actorOf( Props.create( TestingUtils.ForwardingActor.class, getRef(), Option.apply(leaderSessionID) )); resourceManager = system.actorOf( Props.create( TestingYarnFlinkResourceManager.class, flinkConfig, )); leaderRetrievalService.notifyListener(leader1.path().toString(), leaderSessionID); leaderRetrievalService.notifyListener(leader1.path().toString(), leaderSessionID); } finally { if (resourceManager != null) { resourceManager.tell(PoisonPill.getInstance(), ActorRef.noSender());
@Override public void downloadAndIndex(String path, IndexWriter writer) { ActorSystem actorSystem = ActorSystem.create(); ActorRef master = actorSystem.actorOf(Props.create(ParallelMaster.class, new IndexerImpl(writer), new ChaosMonkeyPageRetriever(path))); master.tell(path, actorSystem.guardian()); actorSystem.awaitTermination(); }
.system() .scheduler() .scheduleOnce( (FiniteDuration) Duration.create(0.5, TimeUnit.SECONDS), .system() .scheduler() .scheduleOnce( (FiniteDuration) Duration.create( ParallecGlobalConfig.sshFutureCheckIntervalSec, "ActorMessageTypeInvalidException error for host " + this.targetHost); getSelf().tell(RequestWorkerMsgType.PROCESS_ON_EXCEPTION, getSelf()); this.cause = e; getSelf() .tell(RequestWorkerMsgType.PROCESS_ON_EXCEPTION, getSelf());
statusCodeInt, PcDateUtils.getNowDateTimeStrStandard(), responseHeaders); if (!getContext().system().deadLetters().equals(sender)) { sender.tell(res, getSelf()); getContext().stop(getSelf());
@Override public boolean stopWorker(RegisteredMesosWorkerNode workerNode) { LOG.info("Stopping worker {}.", workerNode.getResourceID()); try { if (workersInLaunch.containsKey(workerNode.getResourceID())) { // update persistent state of worker to Released MesosWorkerStore.Worker worker = workersInLaunch.remove(workerNode.getResourceID()); worker = worker.releaseWorker(); workerStore.putWorker(worker); workersBeingReturned.put(extractResourceID(worker.taskID()), worker); taskMonitor.tell(new TaskMonitor.TaskGoalStateUpdated(extractGoalState(worker)), selfActor); if (worker.hostname().isDefined()) { // tell the launch coordinator that the task is being unassigned from the host, for planning purposes launchCoordinator.tell(new LaunchCoordinator.Unassign(worker.taskID(), worker.hostname().get()), selfActor); } } else if (workersBeingReturned.containsKey(workerNode.getResourceID())) { LOG.info("Ignoring request to stop worker {} because it is already being stopped.", workerNode.getResourceID()); } else { LOG.warn("Unrecognized worker {}.", workerNode.getResourceID()); } } catch (Exception e) { onFatalError(new ResourceManagerException("Unable to release a worker.", e)); } return true; }
getSender().tell(new ResponseFromManager(requestCount), getSelf()); logger.info("req count <=0. return"); + " at " + prepareRequestTimeStr); ActorRef worker = getContext().system().actorOf( Props.create(OperationWorker.class, new TaskRequest(task.getConfig() .getActorMaxOperationTimeoutSec(), maxConcurrency); batchSenderAsstManager = getContext().system().actorOf( Props.create(AssistantExecutionManager.class), "RequestToBatchSenderAsstManager-" + UUID.randomUUID().toString()); batchSenderAsstManager.tell(requestToBatchSenderAsstManager, getSelf()); this.responseCount); batchSenderAsstManager.tell( responseCountToBatchSenderAsstManager, getSelf());
workersInLaunch.put(extractResourceID(worker.taskID()), worker); final LaunchableMesosWorker launchable = createLaunchableMesosWorker(worker.taskID()); toAssign.add(new Tuple2<>(launchable.taskRequest(), worker.hostname().get())); break; case Released: break; taskMonitor.tell(new TaskMonitor.TaskGoalStateUpdated(extractGoalState(worker)), selfActor); launchCoordinator.tell(new LaunchCoordinator.Assign(toAssign), selfActor);
@Test public void testOnReceiveQuarantined() throws Exception { final Throwable t = new RuntimeException("Remote has quarantined this system"); final InvalidAssociation cause = InvalidAssociation.apply(LOCAL, REMOTE, t, Option.apply(null)); final ThisActorSystemQuarantinedEvent event = new ThisActorSystemQuarantinedEvent(LOCAL, REMOTE); actor.tell(event, ActorRef.noSender()); verify(callback, timeout(1000)).apply(); }
public void reply(Object msg) { p.lastMessage().sender().tell(msg, p.ref()); }
if ( queueReadersByQueueName.get( request.getQueueName() ) == null ) { if ( !request.isOnlyIfEmpty() || inMemoryQueue.peek( request.getQueueName()) == null ) { ActorRef readerRef = getContext().actorOf( Props.create( GuiceActorProducer.class, QueueRefresher.class ), request.getQueueName() + "_reader"); queueReadersByQueueName.put( request.getQueueName(), readerRef ); queueReadersByQueueName.get( request.getQueueName() ).tell( request, self() ); ActorRef readerRef = getContext().actorOf( Props.create( GuiceActorProducer.class, QueueTimeouter.class), request.getQueueName() + "_timeouter"); queueTimeoutersByQueueName.put( request.getQueueName(), readerRef ); queueTimeoutersByQueueName.get( request.getQueueName() ).tell( request, self() ); ActorRef readerRef = getContext().actorOf( Props.create( GuiceActorProducer.class, ShardAllocator.class), request.getQueueName() + "_shard_allocator"); shardAllocatorsByQueueName.put( request.getQueueName(), readerRef ); shardAllocatorsByQueueName.get( request.getQueueName() ).tell( request, self() ); getSender().tell( new QueueGetResponse( DistributedQueueService.Status.SUCCESS, messages, queueName ), getSender() );
private void processEndpointRouteMessage(EndpointRouteMessage msg) { EndpointObjectHash endpointKey = msg.getAddress().getEndpointKey(); GlobalEndpointActorMetaData actorMetaData = globalEndpointSessions.get(endpointKey); if (actorMetaData == null) { String endpointActorId = GlobalEndpointActorCreator.generateActorKey(); LOG.debug("[{}] Creating global endpoint actor for endpointKey: {}", appToken, endpointKey); actorMetaData = new GlobalEndpointActorMetaData( context().actorOf(Props.create( new GlobalEndpointActorCreator(context, endpointActorId, appToken, endpointKey)) .withDispatcher(ENDPOINT_DISPATCHER_NAME), endpointActorId), endpointActorId); globalEndpointSessions.put(endpointKey, actorMetaData); context().watch(actorMetaData.actorRef); } actorMetaData.actorRef.tell(msg, self()); }
protected void registered(Registered message) { connectionMonitor.tell(message, selfActor); try { workerStore.setFrameworkID(Option.apply(message.frameworkId())); } catch (Exception ex) { onFatalError(new ResourceManagerException("Unable to store the assigned framework ID.", ex)); return; } launchCoordinator.tell(message, selfActor); reconciliationCoordinator.tell(message, selfActor); taskMonitor.tell(message, selfActor); }
ActorSystem system = ActorSystem.create("PiSystem"); final ActorRef listener = system.actorOf(Props.create(Listener.class), "listener"); ActorRef master = system.actorOf(Props.create(Master.class, nrOfWorkers, nrOfMessages, nrOfElements, listener), "master"); master.tell(new Calculate(), ActorRef.noSender());
@Override public void run(String[] args) throws Exception { try { ActorRef workerActor = actorSystem.actorOf(springExtension.props("workerActor"), "worker-actor"); workerActor.tell(new WorkerActor.Request(), null); workerActor.tell(new WorkerActor.Request(), null); workerActor.tell(new WorkerActor.Request(), null); FiniteDuration duration = FiniteDuration.create(1, TimeUnit.SECONDS); Future<Object> awaitable = Patterns.ask(workerActor, new WorkerActor.Response(), Timeout.durationToTimeout(duration)); logger.info("Response: " + Await.result(awaitable, duration)); } finally { actorSystem.terminate(); Await.result(actorSystem.whenTerminated(), Duration.Inf()); } } }