private void requestSlotFromResourceManager( final AllocationID allocationID, final FlinkCompletableFuture<SimpleSlot> future, final ResourceProfile resources) { LOG.info("Requesting slot with profile {} from resource manager (request = {}).", resources, allocationID); pendingRequests.put(allocationID, new PendingRequest(allocationID, future, resources)); Future<Acknowledge> rmResponse = resourceManagerGateway.requestSlot( jobManagerLeaderId, resourceManagerLeaderId, new SlotRequest(jobId, allocationID, resources, jobManagerAddress), resourceManagerRequestsTimeout); Future<Void> slotRequestProcessingFuture = rmResponse.thenAcceptAsync(new AcceptFunction<Acknowledge>() { @Override public void accept(Acknowledge value) { slotRequestToResourceManagerSuccess(allocationID); } }, getMainThreadExecutor()); // on failure, fail the request future slotRequestProcessingFuture.exceptionallyAsync(new ApplyFunction<Throwable, Void>() { @Override public Void apply(Throwable failure) { slotRequestToResourceManagerFailed(allocationID, failure); return null; } }, getMainThreadExecutor()); }
@Override public void requestHeartbeat(final ResourceID requestOrigin, I heartbeatPayload) { if (!stopped) { log.debug("Received heartbeat request from {}.", requestOrigin); final HeartbeatTarget<O> heartbeatTarget = reportHeartbeat(requestOrigin); if (heartbeatTarget != null) { if (heartbeatPayload != null) { heartbeatListener.reportPayload(requestOrigin, heartbeatPayload); } Future<O> futurePayload = heartbeatListener.retrievePayload(); if (futurePayload != null) { Future<Void> sendHeartbeatFuture = futurePayload.thenAcceptAsync(new AcceptFunction<O>() { @Override public void accept(O retrievedPayload) { heartbeatTarget.receiveHeartbeat(getOwnResourceID(), retrievedPayload); } }, executor); sendHeartbeatFuture.exceptionally(new ApplyFunction<Throwable, Void>() { @Override public Void apply(Throwable failure) { log.warn("Could not send heartbeat to target with id {}.", requestOrigin, failure); return null; } }); } else { heartbeatTarget.receiveHeartbeat(ownResourceID, null); } } } }
/** * Registers an info message listener * * @param address address of infoMessage listener to register to this resource manager */ @RpcMethod public void registerInfoMessageListener(final String address) { if(infoMessageListeners.containsKey(address)) { log.warn("Receive a duplicate registration from info message listener on ({})", address); } else { Future<InfoMessageListenerRpcGateway> infoMessageListenerRpcGatewayFuture = getRpcService().connect(address, InfoMessageListenerRpcGateway.class); Future<Void> infoMessageListenerAcceptFuture = infoMessageListenerRpcGatewayFuture.thenAcceptAsync(new AcceptFunction<InfoMessageListenerRpcGateway>() { @Override public void accept(InfoMessageListenerRpcGateway gateway) { log.info("Receive a registration from info message listener on ({})", address); infoMessageListeners.put(address, gateway); } }, getMainThreadExecutor()); infoMessageListenerAcceptFuture.exceptionallyAsync(new ApplyFunction<Throwable, Void>() { @Override public Void apply(Throwable failure) { log.warn("Receive a registration from unreachable info message listener on ({})", address); return null; } }, getRpcService().getExecutor()); } }
final long globalModVersion = taskExecution.getGlobalModVersion(); terminationFuture.thenAcceptAsync(new AcceptFunction<ExecutionState>() { @Override public void accept(ExecutionState value) {
@Override public void run() { if (!stopped) { log.debug("Trigger heartbeat request."); for (HeartbeatMonitor<O> heartbeatMonitor : getHeartbeatTargets()) { Future<O> futurePayload = getHeartbeatListener().retrievePayload(); final HeartbeatTarget<O> heartbeatTarget = heartbeatMonitor.getHeartbeatTarget(); if (futurePayload != null) { Future<Void> requestHeartbeatFuture = futurePayload.thenAcceptAsync(new AcceptFunction<O>() { @Override public void accept(O payload) { heartbeatTarget.requestHeartbeat(getOwnResourceID(), payload); } }, getExecutor()); requestHeartbeatFuture.exceptionally(new ApplyFunction<Throwable, Void>() { @Override public Void apply(Throwable failure) { log.warn("Could not request the heartbeat from target {}.", heartbeatTarget, failure); return null; } }); } else { heartbeatTarget.requestHeartbeat(getOwnResourceID(), null); } } } }
taskManagerConfiguration.getTimeout()); Future<Void> acceptedSlotsAcceptFuture = acceptedSlotsFuture.thenAcceptAsync(new AcceptFunction<Iterable<SlotOffer>>() { @Override public void accept(Iterable<SlotOffer> acceptedSlots) {
Future<Void> registrationAcceptFuture = registrationFuture.thenAcceptAsync(new AcceptFunction<RegistrationResponse>() { @Override public void accept(RegistrationResponse result) {
Future<Void> resourceManagerAcceptFuture = resourceManagerFuture.thenAcceptAsync(new AcceptFunction<Gateway>() { @Override public void accept(Gateway result) {
@SuppressWarnings("unchecked") public void start() { checkState(!closed, "The RPC connection is already closed"); checkState(!isConnected() && pendingRegistration == null, "The RPC connection is already started"); pendingRegistration = checkNotNull(generateRegistration()); pendingRegistration.startRegistration(); Future<Tuple2<Gateway, Success>> future = pendingRegistration.getFuture(); Future<Void> registrationSuccessFuture = future.thenAcceptAsync(new AcceptFunction<Tuple2<Gateway, Success>>() { @Override public void accept(Tuple2<Gateway, Success> result) { targetGateway = result.f0; onRegistrationSuccess(result.f1); } }, executor); // this future should only ever fail if there is a bug, not if the registration is declined registrationSuccessFuture.exceptionallyAsync(new ApplyFunction<Throwable, Void>() { @Override public Void apply(Throwable failure) { onRegistrationFailure(failure); return null; } }, executor); }