Refine search
private void verifyAndMergeCheckpoints(final Collection<TaskGroup> taskGroupsToVerify) { final List<ListenableFuture<?>> futures = new ArrayList<>(); for (TaskGroup taskGroup : taskGroupsToVerify) { futures.add(workerExec.submit(() -> verifyAndMergeCheckpoints(taskGroup))); } try { Futures.allAsList(futures).get(futureTimeoutInSeconds, TimeUnit.SECONDS); } catch (InterruptedException | ExecutionException | TimeoutException e) { throw new RuntimeException(e); } }
@Test public void testTernaryOperatorsDecimalDouble() throws Exception { for (BigDecimal first : decimalLefts) { for (Double second : doubleMiddle) { for (BigDecimal third : decimalRights) { assertExecute(generateExpression("%s between %s and %s", first, second, third), BOOLEAN, first == null || second == null || third == null ? null : second <= first.doubleValue() && first.compareTo(third) <= 0); } } } Futures.allAsList(futures).get(); }
private void waitForSegmentPublishAndHandoff(long timeout) throws InterruptedException, ExecutionException, TimeoutException { if (!pendingHandoffs.isEmpty()) { ListenableFuture<?> allHandoffs = Futures.allAsList(pendingHandoffs); log.info("Waiting for handoffs"); if (timeout > 0) { allHandoffs.get(timeout, TimeUnit.MILLISECONDS); } else { allHandoffs.get(); } } }
@Test public void testTernaryOperatorsString() throws Exception { for (String first : stringLefts) { for (String second : stringLefts) { for (String third : stringRights) { assertExecute(generateExpression("%s between %s and %s", first, second, third), BOOLEAN, first == null || second == null || third == null ? null : second.compareTo(first) <= 0 && first.compareTo(third) <= 0); } } } Futures.allAsList(futures).get(); }
@Test public void testTernaryOperatorsLongDecimal() throws Exception { for (Long first : longLefts) { for (BigDecimal second : decimalMiddle) { for (Long third : longRights) { assertExecute(generateExpression("%s between %s and %s", first, second, third), BOOLEAN, first == null || second == null || third == null ? null : second.compareTo(new BigDecimal(first)) <= 0 && first <= third); } } } Futures.allAsList(futures).get(); }
/** * Waits for the submitted upload tasks to finish. */ private void waitForAllPartsUpload() throws IOException { int beforeSize = mTags.size(); try { for (ListenableFuture<PartETag> future : mTagFutures) { mTags.add(future.get()); } } catch (ExecutionException e) { // No recover ways so that we need to cancel all the upload tasks // and abort the multipart upload Futures.allAsList(mTagFutures).cancel(true); abortMultiPartUpload(); throw new IOException("Part upload failed in multipart upload with " + "id '" + mUploadId + "' to " + mKey, e); } catch (InterruptedException e) { LOG.warn("Interrupted object upload.", e); Futures.allAsList(mTagFutures).cancel(true); abortMultiPartUpload(); Thread.currentThread().interrupt(); } mTagFutures = new ArrayList<>(); if (mTags.size() != beforeSize) { LOG.debug("Uploaded {} partitions of id '{}' to {}.", mTags.size(), mUploadId, mKey); } }
@Test public void testTernaryOperatorsLongLong() throws Exception { for (Integer first : intLefts) { for (Integer second : intLefts) { for (Integer third : intRights) { assertExecute(generateExpression("%s between %s and %s", first, second, third), BOOLEAN, first == null || second == null || third == null ? null : second <= first && first <= third); } } } Futures.allAsList(futures).get(); }
@Override public Iterator<ServerHolder> pickServersToDrop(DataSegment toDrop, NavigableSet<ServerHolder> serverHolders) { List<ListenableFuture<Pair<Double, ServerHolder>>> futures = new ArrayList<>(); for (final ServerHolder server : serverHolders) { futures.add( exec.submit( () -> Pair.of(computeCost(toDrop, server, true), server) ) ); } final ListenableFuture<List<Pair<Double, ServerHolder>>> resultsFuture = Futures.allAsList(futures); try { // results is an un-ordered list of a pair consisting of the 'cost' of a segment being on a server and the server List<Pair<Double, ServerHolder>> results = resultsFuture.get(); return results.stream() // Comparator.comapringDouble will order by lowest cost... // reverse it because we want to drop from the highest cost servers first .sorted(Comparator.comparingDouble((Pair<Double, ServerHolder> o) -> o.lhs).reversed()) .map(x -> x.rhs).collect(Collectors.toList()) .iterator(); } catch (Exception e) { log.makeAlert(e, "Cost Balancer Multithread strategy wasn't able to complete cost computation.").emit(); } return Collections.emptyIterator(); }
@Test public void testTernaryOperatorsLongDouble() throws Exception { for (Integer first : intLefts) { for (Double second : doubleLefts) { for (Integer third : intRights) { assertExecute(generateExpression("%s between %s and %s", first, second, third), BOOLEAN, first == null || second == null || third == null ? null : second <= first && first <= third); } } } Futures.allAsList(futures).get(); }
@Test public void testTernaryOperatorsDoubleDouble() throws Exception { for (Double first : doubleLefts) { for (Double second : doubleLefts) { for (Integer third : intRights) { assertExecute(generateExpression("%s between %s and %s", first, second, third), BOOLEAN, first == null || second == null || third == null ? null : second <= first && first <= third); } } } Futures.allAsList(futures).get(); }
final ListenableFuture<List<Pair<Double, ServerHolder>>> resultsFuture = Futures.allAsList(futures); final List<Pair<Double, ServerHolder>> bestServers = new ArrayList<>(); bestServers.add(bestServer); try { for (Pair<Double, ServerHolder> server : resultsFuture.get()) { if (server.lhs <= bestServers.get(0).lhs) { if (server.lhs < bestServers.get(0).lhs) {
@Test public void testBinaryOperatorsBigintDecimal() throws Exception { for (Long left : longLefts) { for (BigDecimal right : decimalRights) { assertExecute(generateExpression("%s = %s", left, right), BOOLEAN, left == null || right == null ? null : new BigDecimal(left).equals(right)); assertExecute(generateExpression("%s <> %s", left, right), BOOLEAN, left == null || right == null ? null : !new BigDecimal(left).equals(right)); assertExecute(generateExpression("%s > %s", left, right), BOOLEAN, left == null || right == null ? null : new BigDecimal(left).compareTo(right) > 0); assertExecute(generateExpression("%s < %s", left, right), BOOLEAN, left == null || right == null ? null : new BigDecimal(left).compareTo(right) < 0); assertExecute(generateExpression("%s >= %s", left, right), BOOLEAN, left == null || right == null ? null : new BigDecimal(left).compareTo(right) >= 0); assertExecute(generateExpression("%s <= %s", left, right), BOOLEAN, left == null || right == null ? null : new BigDecimal(left).compareTo(right) <= 0); assertExecute(generateExpression("nullif(%s, %s)", left, right), BIGINT, left); assertExecute(generateExpression("%s is distinct from %s", left, right), BOOLEAN, !Objects.equals(left == null ? null : new BigDecimal(left), right)); // arithmetic operators are already tested in TestDecimalOperators } } Futures.allAsList(futures).get(); }
private void testWithExecutor( final DimFilter filter, final List<String> expectedRows ) { ListeningExecutorService executor = MoreExecutors.listeningDecorator(Executors.newFixedThreadPool(EXECUTOR_NUM_THREADS)); List<ListenableFuture<?>> futures = new ArrayList<>(); for (int i = 0; i < EXECUTOR_NUM_TASKS; i++) { Runnable runnable = makeFilterRunner(filter, expectedRows); ListenableFuture fut = executor.submit(runnable); futures.add(fut); } try { Futures.allAsList(futures).get(60, TimeUnit.SECONDS); } catch (Exception ex) { Assert.fail(ex.getMessage()); } executor.shutdown(); } }
@Test public void testBinaryOperatorsIntegerDecimal() throws Exception { for (Integer left : intLefts) { for (BigDecimal right : decimalRights) { assertExecute(generateExpression("%s = %s", left, right), BOOLEAN, left == null || right == null ? null : new BigDecimal(left).equals(right)); assertExecute(generateExpression("%s <> %s", left, right), BOOLEAN, left == null || right == null ? null : !new BigDecimal(left).equals(right)); assertExecute(generateExpression("%s > %s", left, right), BOOLEAN, left == null || right == null ? null : new BigDecimal(left).compareTo(right) > 0); assertExecute(generateExpression("%s < %s", left, right), BOOLEAN, left == null || right == null ? null : new BigDecimal(left).compareTo(right) < 0); assertExecute(generateExpression("%s >= %s", left, right), BOOLEAN, left == null || right == null ? null : new BigDecimal(left).compareTo(right) >= 0); assertExecute(generateExpression("%s <= %s", left, right), BOOLEAN, left == null || right == null ? null : new BigDecimal(left).compareTo(right) <= 0); assertExecute(generateExpression("nullif(%s, %s)", left, right), INTEGER, left); assertExecute(generateExpression("%s is distinct from %s", left, right), BOOLEAN, !Objects.equals(left == null ? null : new BigDecimal(left), right)); // arithmetic operators are already tested in TestDecimalOperators } } Futures.allAsList(futures).get(); }
private void testWithExecutor( final DimFilter filter, final List<String> expectedRows ) { ListeningExecutorService executor = MoreExecutors.listeningDecorator( Executors.newFixedThreadPool(EXECUTOR_NUM_THREADS) ); List<ListenableFuture<?>> futures = new ArrayList<>(); for (int i = 0; i < EXECUTOR_NUM_TASKS; i++) { Runnable runnable = makeFilterRunner(filter, expectedRows); ListenableFuture fut = executor.submit(runnable); futures.add(fut); } try { Futures.allAsList(futures).get(60, TimeUnit.SECONDS); } catch (Exception ex) { Assert.fail(ex.getMessage()); } executor.shutdown(); } }