public static ListenableFuture<?> done() { return done(true); }
public static void waitAll(ListenableFuture<?>... futures) { AsyncUtils.get(Futures.allAsList(futures)); } }
@Override public boolean evaluate(Host obj) { if (!host.getState().equals(HostConstants.STATE_PROVISIONING)) { throw new ResourceTimeoutException(host, "provisioning canceled"); } return obj.getAgentId() != null; }
public static <T> T get(Future<T> future, long timeout, TimeUnit unit) { try { return future.get(timeout, unit); } catch (InterruptedException e) { throw new IllegalStateException(e); } catch (ExecutionException e) { Throwable t = e.getCause(); ExceptionUtils.rethrowExpectedRuntime(t); throw new UnreachableException(); } catch (TimeoutException e) { throw new io.cattle.platform.async.utils.TimeoutException(e); } }
@Override public ListenableFuture<Event> call(final Event request, EventCallOptions callOptions) { Event unwrappedEvent = buildEvent(request); String state = agentDao.getAgentState(agentId); if (state == null) { return AsyncUtils.error(new AgentRemovedException("Agent [" + agentId + "] is removed", request)); } else if (!GOOD_AGENT_STATES.contains(state)) { return AsyncUtils.error(new TimeoutException()); } return EventCallProgressHelper.call(eventService, unwrappedEvent, Event.class, callOptions, new EventResponseMarshaller() { @SuppressWarnings("unchecked") @Override public <T> T convert(Event resultEvent, Class<T> reply) { Object payload = resultEvent; if (delegate) { payload = resultEvent.getData(); } return (T) new EventVO<>().withName(request.getReplyTo()).withData(payload); } }); }
protected Long getInstanceIdFromThrowable(Throwable t) { Object obj = null; if (t instanceof InstanceException) { obj = ((InstanceException) t).getInstance(); } if (t instanceof ResourceTimeoutException) { obj = ((ResourceTimeoutException) t).getResource(); } if (obj instanceof Instance) { return ((Instance) obj).getId(); } return null; }
public static void waitAll(List<ListenableFuture<?>> futures) { AsyncUtils.get(Futures.allAsList(futures)); }
public static <T> T get(Future<T> future) { try { return future.get(); } catch (InterruptedException e) { throw new IllegalStateException(e); } catch (ExecutionException e) { Throwable t = e.getCause(); if (t instanceof TimeoutException) { throw new io.cattle.platform.async.utils.TimeoutException(t); } ExceptionUtils.rethrowExpectedRuntime(t); throw new UnreachableException(); } }
throw new ResourceTimeoutException(obj, "Waiting: " + predicate.getMessage() + " [" + printKey + "]");
@Override public ListenableFuture<?> whenReady(final ConfigUpdateRequest request) { ConfigUpdate event = getEvent(request); if (event.getData().getItems().size() == 0) { return AsyncUtils.done(); } ListenableFuture<? extends Event> future = request.getUpdateFuture(); if (future == null) { future = call(request.getClient(), event); } return Futures.transform(future, new Function<Event, Object>() { @Override public Object apply(Event input) { logResponse(request, input); List<ConfigUpdateItem> toTrigger = getNeedsUpdating(request, true); if (toTrigger.size() > 0) { throw new ConfigTimeoutException(request, toTrigger); } return Boolean.TRUE; } }); }
@Override public void waitFor(ConfigUpdateRequest request) { AsyncUtils.get(whenReady(request)); }
private synchronized boolean waitForExecutor(boolean executorRunning) { if (!LAUNCH_COMPOSE_EXECUTOR.get()) { return true; } if (executorRunning) { return executorRunning; } for (int i = 0; i < 120; i++) { ExternalHandler handler = objectManager.findAny(ExternalHandler.class, ObjectMetaDataManager.NAME_FIELD, "rancher-compose-executor", ObjectMetaDataManager.STATE_FIELD, CommonStatesConstants.ACTIVE); if (handler != null) { return true; } log.info("Waiting for rancher-compose-executor"); try { Thread.sleep(2000); } catch (InterruptedException e) { throw new IllegalStateException(e); } } throw new TimeoutException("Failed to find rancher-compose-executor"); }
@Override public boolean evaluate(final PhysicalHost obj) { boolean transitioning = objectMetaDataManager.isTransitioningState(obj.getClass(), obj.getState()); if (!transitioning) { return true; } objectManager.reload(host); if (!host.getState().equals(HostConstants.STATE_PROVISIONING)) { throw new ResourceTimeoutException(host, "provisioning canceled"); } String message = TransitioningUtils.getTransitioningMessage(obj); objectManager.setFields(host, ObjectMetaDataManager.TRANSITIONING_MESSAGE_FIELD, message); DeferredUtils.nest(new Runnable() { @Override public void run() { ObjectUtils.publishChanged(eventService, objectManager, host); } }); return false; }
@Override public Event callSync(Event event, EventCallOptions options) { return AsyncUtils.get(call(event, options)); }
@Override public boolean evaluate(Instance obj) { if (obj.getRemoved() != null) { throw new TimeoutException("Instance is removed"); } if (ERROR_STATES.contains(obj.getState())) { throw new TimeoutException("Instance encountered an error"); } if (isStartOnce(obj)) { return START_ONCE_STATES.contains(obj.getState()); } InstanceHostMap ihm = objectManager.findAny(InstanceHostMap.class, INSTANCE_HOST_MAP.INSTANCE_ID, obj.getId(), INSTANCE_HOST_MAP.STATE, CommonStatesConstants.ACTIVE, INSTANCE_HOST_MAP.REMOVED, null); return ihm != null; }
@Override public Event callSync(Event event, EventCallOptions callOptions) { return AsyncUtils.get(call(event, callOptions)); }
Future<?> future = retry.getFuture(); if (future instanceof SettableFuture) { ((SettableFuture<?>) future).setException(new TimeoutException()); } else { future.cancel(true);
protected boolean doOp(LockDefinition lockDef, boolean lock) { SettableFuture<Boolean> future = SettableFuture.create(); ops.add(new LockOp(lockDef, lock, future)); return AsyncUtils.get(future); }
@Override public PooledObject<FutureEventListener> makeObject() throws Exception { String key = prefix + Math.abs(random.nextLong()); FutureEventListener listener = new FutureEventListener(eventService, key); Future<?> future = eventService.subscribe(key, listener); AsyncUtils.get(future, 10, TimeUnit.SECONDS); return new DefaultPooledObject<FutureEventListener>(listener); }
@Override public <T extends Event> T callSync(Event event, Class<T> reply, EventCallOptions options) { /* * NOTE: Forever blocking get() used only because underlying future will * always timeout */ try { return AsyncUtils.get(call(event, reply, options)); } catch (TimeoutException e) { Agent agent = objectManager.loadResource(Agent.class, agentId); if (agent == null || agent.getRemoved() != null) { throw new AgentRemovedException("Agent [" + agentId + "] is removed", event); } throw e; } catch (AgentRemovedException e) { throw e; } catch (EventExecutionException e) { /* * This is done so that the exception will have a better stack * trace. Normally the exceptions from a future will have a pretty * sparse stack not giving too much context */ throw EventExecutionException.fromEvent(e.getEvent()); } }