/** * Create a new Promise that has been resolved with the specified value. * * @param value The value of the resolved Promise. * @param <T> The value type associated with the returned Promise. * @return A new Promise that has been resolved with the specified value. */ public static <T> Promise<T> resolved(T value) { Deferred<T> def = new Deferred<T>(); def.resolve(value); return def.getPromise(); }
@Override public <T> CancellablePromiseImpl<T> after(Callable<T> callable, long ms) { Deferred<T> deferred = new Deferred<>(); ScheduledFuture<?> schedule = getExecutor().schedule(() -> { try { deferred.resolve(callable.call()); } catch (Throwable e) { deferred.fail(e); } }, ms, TimeUnit.MILLISECONDS); return new CancellablePromiseImpl<T>(deferred.getPromise()) { public boolean cancel() { try { return schedule.cancel(true); } catch (Exception e) { return false; } } }; }
/** * Create a new Promise that has been resolved with the specified failure. * * @param failure The failure of the resolved Promise. Must not be null. * @param <T> The value type associated with the returned Promise. * @return A new Promise that has been resolved with the specified failure. */ public static <T> Promise<T> failed(Throwable failure) { if (failure == null) throw new NullPointerException(); Deferred<T> def = new Deferred<T>(); def.fail(failure); return def.getPromise(); }
@Override public Promise<Optional<T>> findFirst() { Deferred<Optional<T>> d = promiseFactory.deferred(); updateNext((event) -> { try { Optional<T> o = null; switch(event.getType()) { case DATA: o = Optional.of(event.getData()); break; case CLOSE: o = Optional.empty(); break; case ERROR: d.fail(event.getFailure()); return ABORT; } if(!d.getPromise().isDone()) d.resolve(o); return ABORT; } catch (Exception e) { close(PushEvent.error(e)); return ABORT; } }); begin(); return d.getPromise(); }
public <V> Promise<V> invokeAsynchronously(Bundle clientBundle, ExecutorService executor) { Deferred<V> deferred = new Deferred<V>(); svc = getService(); } catch (Exception e) { deferred.fail(e); return deferred.getPromise(); if(p != null) { try { deferred.resolveWith(p); return deferred.getPromise(); } finally { releaseService(); deferred.fail(e); return deferred.getPromise(); } finally { releaseService(); executor.execute(new Work<V>(this, deferred)); } catch (RejectedExecutionException ree) { deferred.fail(new ServiceException("The Async service is unable to accept new requests", 7, ree)); Promise<V> promise = deferred.getPromise();
private Promise<List<Artifact>> getArtifacts(Set<URI> cycles, final Collection<URI> uris) { Deferred<List<Artifact>> deferred = promiseFactory.deferred(); promiseFactory.executor() .execute(() -> { try { deferred.resolveWith(uris.stream() .map(uri -> getArtifacts(cycles, base.resolve(uri)).recover(failed -> { if (!defaults.contains(uri)) { logger.info("Failed to get artifacts for %s", uri, failed.getFailure()); } return Collections.emptyList(); })) .collect(toPromise(promiseFactory)) .map(ll -> ll.stream() .flatMap(List::stream) .collect(toList()))); } catch (Throwable e) { deferred.fail(e); } }); return deferred.getPromise(); }
enabledLatch.getPromise().getValue(); waited = true; newEnabledLatch = new Deferred<>();
@Override public Object get(long timeout, TimeUnit unit) throws Exception { return deferred.getPromise(); } }
public AsyncResponseFuture(ClassLoader loader, Method method, SerializationStrategy serializationStrategy, DispatchQueue queue) { this.loader = loader; this.method = method; this.serializationStrategy = serializationStrategy; this.queue = queue; this.deferred = new Deferred<>(); }
@Override public Promise<Void> disableComponents( final boolean async ) { synchronized (enableLock) { if ( m_disablePromise != null) { return m_disablePromise; } wait( m_enablePromise ); List<AbstractComponentManager<S>> cms; synchronized ( m_components ) { m_enabled = false; cms = getDirectComponentManagers( ); clearComponents(); } List<Promise<Void>> promises = new ArrayList<>(); for ( AbstractComponentManager<S> cm : cms ) { promises.add(cm.disable( async )); } m_disablePromise = new Deferred<List<Void>>().resolveWith(Promises.<Void, Void>all(promises)); m_enablePromise = null; return m_disablePromise; } }
private Promise<Long> doSendWithBackPressure( PushEventConsumer< ? super T> pec, PushEvent<T> event) { Deferred<Long> d = sameThread.deferred(); try { promiseFactory.executor().execute( () -> d.resolve(Long.valueOf( System.nanoTime() + safePush(pec, event)))); } catch (RejectedExecutionException ree) { // TODO log? if (!event.isTerminal()) { close(PushEvent.error(ree)); d.resolve(Long.valueOf(System.nanoTime())); } else { d.resolve( Long.valueOf(System.nanoTime() + safePush(pec, event))); } } return d.getPromise(); }
private BridgeRepository getBridge() throws Exception { Promise<BridgeRepository> promise = repository.getPromise(); if (!promise.isDone()) { repository.resolveWith(readFiles()); } return promise.getValue(); }
@Override public void onSuccess(Object result) { deferred.resolve(result); }
@Override public boolean cancel() { try { deferred.fail(CancelException.SINGLETON); return true; } catch (Exception e) { return false; } } }
private void close(PushEvent<T> event) { List<PushEventConsumer< ? super T>> toClose; Deferred<Void> toFail = null; synchronized (lock) { if(!closed) { closed = true; toClose = new ArrayList<>(connected); connected.clear(); queue.clear(); if(connectPromise != null) { toFail = connectPromise; connectPromise = null; } } else { toClose = emptyList(); } } toClose.stream().forEach(pec -> doSend(pec, event)); if (toFail != null) { toFail.resolveWith(closedConnectPromise()); } onClose.run(); }
@Override public Promise<Optional<T>> findFirst() { Deferred<Optional<T>> d = promiseFactory.deferred(); updateNext((event) -> { try { Optional<T> o = null; switch(event.getType()) { case DATA: o = Optional.of(event.getData()); break; case CLOSE: o = Optional.empty(); break; case ERROR: d.fail(event.getFailure()); return ABORT; } if(!d.getPromise().isDone()) d.resolve(o); return ABORT; } catch (Exception e) { close(PushEvent.error(e)); return ABORT; } }); begin(); return d.getPromise(); }
Deferred<List<URI>> deferred = new Deferred<>(); return jars; }); deferred.resolveWith(result); } catch (Throwable e) { deferred.fail(e); Exceptions.duck(e); return deferred.getPromise();
private Promise<List<Artifact>> getArtifacts(Set<URI> cycles, final Collection<URI> uris) { Deferred<List<Artifact>> deferred = promiseFactory.deferred(); promiseFactory.executor() .execute(() -> { try { deferred.resolveWith(uris.stream() .map(uri -> getArtifacts(cycles, base.resolve(uri)).recover(failed -> { if (!defaults.contains(uri)) { logger.info("Failed to get artifacts for %s", uri, failed.getFailure()); } return Collections.emptyList(); })) .collect(toPromise(promiseFactory)) .map(ll -> ll.stream() .flatMap(List::stream) .collect(toList()))); } catch (Throwable e) { deferred.fail(e); } }); return deferred.getPromise(); }
enabledLatch.getPromise().getValue(); waited = true; newEnabledLatch = new Deferred<>();