@Override public void onFailure(Throwable failure) { deferred.fail(failure); }
@Override public boolean cancel() { try { deferred.fail(CancelException.SINGLETON); return true; } catch (Exception e) { return false; } } }
@Override public void fail(Promise<?> resolved) throws Exception { failedPromises.add(resolved); if (failedPromises.size() + resolvedValues.size() == promises.size()) { result.fail(new FailedPromisesException(failedPromises)); } } });
public boolean cancel() { try { return only.once(() -> d.fail(CancelException.SINGLETON)); } catch (Exception e) { return false; } } };
@Override public Promise<T> call(Promise<S> resolved) throws Exception { // "S is subtype of the value type of the List" @SuppressWarnings("unchecked") T value = (T) resolved.getValue(); resolvedValues.add(value); if (resolvedValues.size() == promises.size()) { result.resolve(resolvedValues); } else if (failedPromises.size() + resolvedValues.size() == promises.size()) { result.fail(new FailedPromisesException(failedPromises)); } return null; } }, new Failure() {
public void run() { try { final Object service = methodCall.getService(); // This is necessary for non public methods. The original mediator call must // have been allowed to happen, so this should always be safe. methodCall.method.setAccessible(true); AccessController.doPrivileged(new PrivilegedAction<Void>() { public Void run() { started.resolve(null); try { methodCall.method.invoke(service, methodCall.arguments); cleanup.resolve(null); } catch (InvocationTargetException ite) { cleanup.fail(ite.getTargetException()); } catch (Exception e) { cleanup.fail(e); } return null; } }, acc); } catch (Exception e) { started.fail(e); cleanup.fail(e); } finally { methodCall.releaseService(); } } }
/** * 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(); }
public void run() { try { final Object service = methodCall.getService(); // This is necessary for non public methods. The original mediator call must // have been allowed to happen, so this should always be safe. methodCall.method.setAccessible(true); @SuppressWarnings("unchecked") T returnValue = AccessController.doPrivileged(new PrivilegedExceptionAction<T>() { public T run() throws Exception { return (T) methodCall.method.invoke(service, methodCall.arguments); } }, acc); deferred.resolve(returnValue); } catch (PrivilegedActionException pae) { Throwable targetException = pae.getCause(); if(targetException instanceof InvocationTargetException) { targetException = ((InvocationTargetException) targetException).getTargetException(); } deferred.fail(targetException); } catch (Exception e) { deferred.fail(e); } finally { methodCall.releaseService(); } } }
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(); }
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(); }
@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; } } }; }
@Override public Promise<Optional<T>> reduce(BinaryOperator<T> accumulator) { Deferred<Optional<T>> d = promiseFactory.deferred(); AtomicReference<T> iden = new AtomicReference<T>(null); updateNext(event -> { try { switch(event.getType()) { case DATA: if (!iden.compareAndSet(null, event.getData())) iden.accumulateAndGet(event.getData(), accumulator); return CONTINUE; case CLOSE: d.resolve(Optional.ofNullable(iden.get())); break; case ERROR: d.fail(event.getFailure()); break; } close(event.nodata()); return ABORT; } catch (Exception e) { close(PushEvent.error(e)); return ABORT; } }); begin(); return d.getPromise(); }
@Override public <U> Promise<U> reduce(U identity, BiFunction<U, ? super T, U> accumulator, BinaryOperator<U> combiner) { Deferred<U> d = promiseFactory.deferred(); AtomicReference<U> iden = new AtomicReference<>(identity); updateNext(event -> { try { switch(event.getType()) { case DATA: iden.updateAndGet((e) -> accumulator.apply(e, event.getData())); return CONTINUE; case CLOSE: d.resolve(iden.get()); break; case ERROR: d.fail(event.getFailure()); break; } close(event.nodata()); return ABORT; } catch (Exception e) { close(PushEvent.error(e)); return ABORT; } }); begin(); return d.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(); }
@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(); }
@Override public Promise<T> reduce(T identity, BinaryOperator<T> accumulator) { Deferred<T> d = promiseFactory.deferred(); AtomicReference<T> iden = new AtomicReference<T>(identity); updateNext(event -> { try { switch(event.getType()) { case DATA: iden.accumulateAndGet(event.getData(), accumulator); return CONTINUE; case CLOSE: d.resolve(iden.get()); break; case ERROR: d.fail(event.getFailure()); break; } close(event.nodata()); return ABORT; } catch (Exception e) { close(PushEvent.error(e)); return ABORT; } }); begin(); return d.getPromise(); }
@Override public Promise<Void> forEach(Consumer< ? super T> action) { Deferred<Void> d = promiseFactory.deferred(); updateNext((event) -> { try { switch(event.getType()) { case DATA: action.accept(event.getData()); return CONTINUE; case CLOSE: d.resolve(null); break; case ERROR: d.fail(event.getFailure()); break; } close(event.nodata()); return ABORT; } catch (Exception e) { close(PushEvent.error(e)); return ABORT; } }); begin(); return d.getPromise(); }
@Override public Promise<Void> forEach(Consumer< ? super T> action) { Deferred<Void> d = promiseFactory.deferred(); updateNext((event) -> { try { switch(event.getType()) { case DATA: action.accept(event.getData()); return CONTINUE; case CLOSE: d.resolve(null); break; case ERROR: d.fail(event.getFailure()); break; } close(event.nodata()); return ABORT; } catch (Exception e) { close(PushEvent.error(e)); return ABORT; } }); begin(); return d.getPromise(); }
@Override public Promise<Long> count() { Deferred<Long> d = promiseFactory.deferred(); LongAdder counter = new LongAdder(); updateNext((event) -> { try { switch(event.getType()) { case DATA: counter.add(1); return CONTINUE; case CLOSE: d.resolve(Long.valueOf(counter.sum())); break; case ERROR: d.fail(event.getFailure()); break; } close(event.nodata()); return ABORT; } catch (Exception e) { close(PushEvent.error(e)); return ABORT; } }); begin(); return d.getPromise(); }