@SuppressWarnings("unchecked") protected void doService(SerializationStrategy serializationStrategy, ClassLoader loader, Method method, Object target, DataByteArrayInputStream requestStream, final DataByteArrayOutputStream responseStream, final Runnable onComplete) { final AsyncServiceResponse helper = new AsyncServiceResponse(loader, method, responseStream, onComplete, serializationStrategy); try { Class<?>[] types = method.getParameterTypes(); final Object[] args = new Object[types.length]; serializationStrategy.decodeRequest(loader, types, requestStream, args); final Promise<Object> promise = (Promise<Object>)method.invoke(target, args); promise.onResolve(() -> { try{ helper.send(promise.getFailure(), promise.getFailure()==null ? promise.getValue() : null); } catch (Exception e){ helper.send(e, null); } }); } catch (Throwable t) { helper.send(t, null); } }
public <R> Promise<R> then(Success<? super T, ? extends R> success, Failure failure) { return promise.then(success, failure); }
@Override public void fail(Promise<?> resolved) throws Exception { @SuppressWarnings({"not thrown", "all"}) Throwable fail = fallback.getFailure(); if (fail != null) { result.fail(resolved.getFailure()); } else { result.resolve(fallback.getValue()); } } });
/** * Run the specified chain when the specified promise is resolved. * * @param promise The promise associated with the chain. * @param chain The chain to run when the promise is resolved. */ static <V> void chain(Promise<V> promise, Runnable chain) { if (promise.isDone()) { try { chain.run(); } catch (Throwable t) { uncaughtException(t); } } else { promise.onResolve(chain); } }
public void fail(Promise<?> resolved) throws Exception { Throwable failure; try { failure = resolved.getFailure(); } catch (Throwable e) { chained.resolve(null, e); return; } fallback.onResolve(new Chain<T>(chained, fallback, failure)); } }
for (URI uri : uris) { if (freshness.getPromise() .isDone()) { break; // early exit if staleness already detected .asTag() .async(uri); promises.add(async.then(resolved -> { switch (resolved.getValue() .getState()) { case OTHER : logger.debug("Could not verify {}: {}", uri, resolved.getFailure()); freshness.fail(resolved.getFailure()); })); for (Revision revision : revisions) { if (freshness.getPromise() .isDone()) { break; // early exit if staleness already detected promises.add(file.then(resolved -> { File f = resolved.getValue(); if (f.isFile() && f.lastModified() > lastModified) { logger.debug("Found {} to be stale", revision); logger.debug("Could not verify {}: {}", revision, resolved.getFailure()); freshness.fail(resolved.getFailure()); }));
/** * Return a holder of the result of the specified Promise. * * @since 1.1 */ static <R> Result<R> collect(Promise< ? extends R> promise) { if (promise instanceof PromiseImpl) { @SuppressWarnings("unchecked") PromiseImpl<R> impl = (PromiseImpl<R>) promise; return impl.collect(); } if (!promise.isDone()) { return new Result<R>(new AssertionError("promise not resolved")); } final boolean interrupted = Thread.interrupted(); try { Throwable fail = promise.getFailure(); if (fail == null) { return new Result<R>(promise.getValue()); } return new Result<R>(fail); } catch (Throwable e) { return new Result<R>(e); // propagate new exception } finally { if (interrupted) { // restore interrupt status Thread.currentThread().interrupt(); } } } }
@SuppressWarnings("unchecked") public Promise<R> call(Promise<T> resolved) throws Exception { return (Promise<R>) mapper.apply(resolved.getValue()); } }
/** * Return a new Promise that will fail after timeout ms with a * {@link TimeoutException} */ // @Override public <T> CancellablePromiseImpl<T> before(Promise<T> promise, long timeout) { Deferred<T> d = new Deferred<T>(); Unique only = new Unique(); after(timeout).then((p) -> { only.once(() -> d.fail(TimeoutException.SINGLETON)); return null; }); promise.then((p) -> { only.once(() -> d.resolve(p.getValue())); return null; }, (p) -> { only.once(() -> d.fail(p.getFailure())); }); return new CancellablePromiseImpl<T>(d.getPromise()) { public boolean cancel() { try { return only.once(() -> d.fail(CancelException.SINGLETON)); } catch (Exception e) { return false; } } }; }
public Throwable getFailure() throws InterruptedException { return promise.getFailure(); }
public Promise<T> onResolve(Runnable callback) { return promise.onResolve(callback); }
private Promise<Long> deliver(List<PushEventConsumer< ? super T>> toCall, PushEvent<T> event) { if (toCall.size() == 1) { return doCall(event, toCall.get(0)); } else { List<Promise<Long>> calls = toCall.stream().map(pec -> { if (semaphore.tryAcquire()) { return doSendWithBackPressure(pec, event) .onResolve(() -> semaphore.release()); } else { return doCall(event, pec); } }).collect(toList()); return sameThread.all(calls) .map(l -> l.stream().max(Long::compareTo).orElseGet( () -> Long.valueOf(System.nanoTime()))); } }
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(); }
public boolean isDone() { return promise.isDone(); }
@Override public Promise<Object[]> toArray() { return collect(Collectors.toList()) .map(List::toArray); }
try { executor.execute(new FireAndForgetWork(this, cleanup, started)); cleanup.getPromise().onResolve(new Runnable() { public void run() { releaseService(); }).then(null, new Failure(){ public void fail(Promise<?> resolved) throws Exception { logError("The fire-and-forget invocation failed", resolved.getFailure());
this.dls = downloadListeners; logger.debug("{}: starting", task); promise.thenAccept(file -> { if (file == null) { throw new FileNotFoundException("Download failed"); .onFailure(failure -> { logger.debug("{}: failure", this, failure); String reason = Exceptions.toString(failure);
private Promise<Resource> parseFile(File file) { Promise<Resource> resource = promiseFactory.submit(() -> { if (!file.isFile()) { return null; } ResourceBuilder rb = new ResourceBuilder(); try (JarFile jar = new JarFile(file)) { Domain manifest = Domain.domain(jar.getManifest()); boolean hasIdentity = rb.addManifest(manifest); if (!hasIdentity) { return null; } } catch (Exception f) { return null; } logger.debug("{}: parsing {}", getName(), file); Attrs attrs = new Attrs(); attrs.put(ContentNamespace.CAPABILITY_URL_ATTRIBUTE, file.toURI() .toString()); attrs.putTyped(ContentNamespace.CAPABILITY_SIZE_ATTRIBUTE, file.length()); attrs.put(ContentNamespace.CONTENT_NAMESPACE, SHA256.digest(file) .asHex()); rb.addCapability(CapReqBuilder.createCapReqBuilder(ContentNamespace.CONTENT_NAMESPACE, attrs)); return rb.build(); }); if (logger.isDebugEnabled()) { resource.onFailure(failure -> logger.debug("{}: failed to parse {}", getName(), file, failure)); } return resource; }
for (URI uri : uris) { if (freshness.getPromise() .isDone()) { break; // early exit if staleness already detected .asTag() .async(uri); promises.add(async.then(resolved -> { switch (resolved.getValue() .getState()) { case OTHER : logger.debug("Could not verify {}: {}", uri, resolved.getFailure()); freshness.fail(resolved.getFailure()); })); for (Revision revision : revisions) { if (freshness.getPromise() .isDone()) { break; // early exit if staleness already detected promises.add(file.then(resolved -> { File f = resolved.getValue(); if (f.isFile() && f.lastModified() > lastModified) { logger.debug("Found {} to be stale", revision); logger.debug("Could not verify {}: {}", revision, resolved.getFailure()); freshness.fail(resolved.getFailure()); }));