Traverser(MavenRepository repo, HttpClient client, boolean transitive) { this.repo = repo; this.client = client; this.promiseFactory = client.promiseFactory(); this.deferred = promiseFactory.deferred(); this.transitive = transitive; this.revisions = new ArrayList<>(); this.uris = new ArrayList<>(); }
Traverser(MavenRepository repo, HttpClient client, boolean transitive) { this.repo = repo; this.client = client; this.promiseFactory = client.promiseFactory(); this.deferred = promiseFactory.deferred(); this.transitive = transitive; this.revisions = new ArrayList<>(); this.uris = new ArrayList<>(); }
public FileSetRepository(String name, Collection<File> files) throws Exception { this.name = name; this.files = files; promiseFactory = new PromiseFactory(PromiseFactory.inlineExecutor()); repository = promiseFactory.deferred(); }
public FileSetRepository(String name, Collection<File> files) throws Exception { this.name = name; this.files = files; promiseFactory = new PromiseFactory(PromiseFactory.inlineExecutor()); repository = promiseFactory.deferred(); }
@Override public Promise<Void> connectPromise() { synchronized (lock) { if (closed) { return closedConnectPromise(); } if (connected.isEmpty()) { if (connectPromise == null) { connectPromise = promiseFactory.deferred(); } return connectPromise.getPromise(); } else { return promiseFactory.resolved(null); } } }
@Override public Promise<Void> connectPromise() { synchronized (lock) { if (closed) { return closedConnectPromise(); } if (connected.isEmpty()) { if (connectPromise == null) { connectPromise = promiseFactory.deferred(); } return connectPromise.getPromise(); } else { return promiseFactory.resolved(null); } } }
@Override public Promise<Void> connectPromise() { synchronized (lock) { if (closed) { return closedConnectPromise(); } if (connected.isEmpty()) { if (connectPromise == null) { connectPromise = promiseFactory.deferred(); } return connectPromise.getPromise(); } else { return promiseFactory.resolved(null); } } }
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(); }
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 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 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 Promise<POM> getPomPromise(final Revision revision) throws Exception { Deferred<POM> deferred; synchronized (poms) { Promise<POM> promise = poms.get(revision); if (promise != null) { return promise; } deferred = promiseFactory.deferred(); poms.put(revision, deferred.getPromise()); } Archive pomArchive = revision.getPomArchive(); deferred.resolveWith(get(pomArchive, false).map(pomFile -> { if (pomFile == null) { return null; } try { return getPom(pomFile); } catch (Exception e) { logger.error("Failed to parse pom {} from file {}", revision, pomFile, e); return null; } })); return deferred.getPromise(); }
private Promise<POM> getPomPromise(final Revision revision) throws Exception { Deferred<POM> deferred; synchronized (poms) { Promise<POM> promise = poms.get(revision); if (promise != null) { return promise; } deferred = promiseFactory.deferred(); poms.put(revision, deferred.getPromise()); } Archive pomArchive = revision.getPomArchive(); deferred.resolveWith(get(pomArchive, false).map(pomFile -> { if (pomFile == null) { return null; } try { return getPom(pomFile); } catch (Exception e) { logger.error("Failed to parse pom {} from file {}", revision, pomFile, e); return null; } })); return deferred.getPromise(); }
@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<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<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(); }