Examples with SimpleTimeLimiter com.google.common.util.concurrent.SimpleTimeLimiter used on opensource projects

Example 1 with SimpleTimeLimiter

use of com.google.common.util.concurrent.SimpleTimeLimiter in project zipkin by openzipkin.

the class HttpCallTest method propagatesOnDispatcherThreadWhenFatal.

@Test
public void propagatesOnDispatcherThreadWhenFatal() throws Exception {
    mws.enqueue(new MockResponse());
    http.newCall(request, b -> {
        throw new LinkageError();
    }).submit(callback);
    SimpleTimeLimiter timeLimiter = new SimpleTimeLimiter();
    try {
        timeLimiter.callWithTimeout(callback::get, 100, TimeUnit.MILLISECONDS, true);
        failBecauseExceptionWasNotThrown(UncheckedTimeoutException.class);
    } catch (UncheckedTimeoutException expected) {
    }
}

Example 2 with SimpleTimeLimiter

use of com.google.common.util.concurrent.SimpleTimeLimiter in project presto by prestodb.

the class Validator method executeQuery.

private QueryResult executeQuery(String url, String username, String password, Query query, String sql, Duration timeout, Map<String, String> sessionProperties) {
    String queryId = null;
    try (Connection connection = DriverManager.getConnection(url, username, password)) {
        trySetConnectionProperties(query, connection);
        for (Map.Entry<String, String> entry : sessionProperties.entrySet()) {
            connection.unwrap(PrestoConnection.class).setSessionProperty(entry.getKey(), entry.getValue());
        }
        try (Statement statement = connection.createStatement()) {
            TimeLimiter limiter = new SimpleTimeLimiter();
            Stopwatch stopwatch = Stopwatch.createStarted();
            Statement limitedStatement = limiter.newProxy(statement, Statement.class, timeout.toMillis(), TimeUnit.MILLISECONDS);
            if (explainOnly) {
                sql = "EXPLAIN " + sql;
            }
            long start = System.nanoTime();
            PrestoStatement prestoStatement = limitedStatement.unwrap(PrestoStatement.class);
            ProgressMonitor progressMonitor = new ProgressMonitor();
            prestoStatement.setProgressMonitor(progressMonitor);
            try {
                boolean isSelectQuery = limitedStatement.execute(sql);
                List<List<Object>> results = null;
                if (isSelectQuery) {
                    results = limiter.callWithTimeout(getResultSetConverter(limitedStatement.getResultSet()), timeout.toMillis() - stopwatch.elapsed(TimeUnit.MILLISECONDS), TimeUnit.MILLISECONDS, true);
                } else {
                    results = ImmutableList.of(ImmutableList.of(limitedStatement.getLargeUpdateCount()));
                }
                prestoStatement.clearProgressMonitor();
                QueryStats queryStats = progressMonitor.getFinalQueryStats();
                if (queryStats == null) {
                    throw new VerifierException("Cannot fetch query stats");
                }
                Duration queryCpuTime = new Duration(queryStats.getCpuTimeMillis(), TimeUnit.MILLISECONDS);
                queryId = queryStats.getQueryId();
                return new QueryResult(State.SUCCESS, null, nanosSince(start), queryCpuTime, queryId, results);
            } catch (AssertionError e) {
                if (e.getMessage().startsWith("unimplemented type:")) {
                    return new QueryResult(State.INVALID, null, null, null, queryId, ImmutableList.of());
                }
                throw e;
            } catch (SQLException | VerifierException e) {
                throw e;
            } catch (UncheckedTimeoutException e) {
                return new QueryResult(State.TIMEOUT, null, null, null, queryId, ImmutableList.of());
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
                throw Throwables.propagate(e);
            } catch (Exception e) {
                throw Throwables.propagate(e);
            }
        }
    } catch (SQLException e) {
        Exception exception = e;
        if (("Error executing query".equals(e.getMessage()) || "Error fetching results".equals(e.getMessage())) && (e.getCause() instanceof Exception)) {
            exception = (Exception) e.getCause();
        }
        State state = isPrestoQueryInvalid(e) ? State.INVALID : State.FAILED;
        return new QueryResult(state, exception, null, null, null, null);
    } catch (VerifierException e) {
        return new QueryResult(State.TOO_MANY_ROWS, e, null, null, null, null);
    }
}

Example 3 with SimpleTimeLimiter

use of com.google.common.util.concurrent.SimpleTimeLimiter in project symja_android_library by axkr.

the class ExprEvaluator method evaluateWithTimeout.

/**
	 * <p>
	 * Parse the given <code>expression String</code> and evaluate it to an IExpr value.
	 * </p>
	 * 
	 * @param inputExpression
	 *            the Symja input expression
	 * @param timeoutDuration
	 *            with timeoutUnit, the maximum length of time to wait
	 * @param timeUnit
	 *            with timeoutDuration, the maximum length of time to wait
	 * @param interruptible
	 *            whether to respond to thread interruption by aborting the operation and throwing InterruptedException;
	 *            if false, the operation is allowed to complete or time out, and the current thread's interrupt status
	 *            is re-asserted.
	 * @return
	 * @throws SyntaxError
	 */
public IExpr evaluateWithTimeout(final String inputExpression, long timeoutDuration, TimeUnit timeUnit, boolean interruptible) {
    if (inputExpression != null) {
        EvalEngine.set(engine);
        engine.reset();
        fExpr = engine.parse(inputExpression);
        if (fExpr != null) {
            F.join();
            TimeLimiter timeLimiter = new SimpleTimeLimiter();
            Callable<IExpr> work = new EvalCallable(fExpr, engine);
            try {
                return timeLimiter.callWithTimeout(work, timeoutDuration, timeUnit, interruptible);
            } catch (java.util.concurrent.TimeoutException e) {
                return F.Aborted;
            } catch (com.google.common.util.concurrent.UncheckedTimeoutException e) {
                return F.Aborted;
            } catch (Exception e) {
                if (Config.DEBUG) {
                    e.printStackTrace();
                }
                return F.Null;
            }
        }
    }
    return null;
}

Example 4 with SimpleTimeLimiter

use of com.google.common.util.concurrent.SimpleTimeLimiter in project symja_android_library by axkr.

the class TimeConstrained method evaluate.

@Override
public IExpr evaluate(final IAST ast, EvalEngine engine) {
    Validate.checkRange(ast, 3, 4);
    IExpr arg2 = engine.evaluate(ast.arg2());
    long seconds = 0L;
    try {
        if (arg2.isSignedNumber()) {
            seconds = ((ISignedNumber) arg2).toLong();
        } else {
            engine.printMessage("TimeConstrained: " + ast.arg2().toString() + " is not a Java long value.");
            return F.NIL;
        }
    } catch (ArithmeticException ae) {
        engine.printMessage("TimeConstrained: " + ast.arg2().toString() + " is not a Java long value.");
        return F.NIL;
    }
    if (Config.JAS_NO_THREADS) {
        // no thread can be spawned
        try {
            return engine.evaluate(ast.arg1());
        } catch (final MathException e) {
            throw e;
        } catch (final Throwable th) {
            if (ast.isAST3()) {
                return ast.arg3();
            }
        }
        return F.Aborted;
    } else {
        TimeLimiter timeLimiter = new SimpleTimeLimiter();
        Callable<IExpr> work = new EvalCallable(ast.arg1(), engine);
        try {
            return timeLimiter.callWithTimeout(work, seconds, TimeUnit.SECONDS, true);
        } catch (java.util.concurrent.TimeoutException e) {
            if (ast.isAST3()) {
                return ast.arg3();
            }
            return F.Aborted;
        } catch (com.google.common.util.concurrent.UncheckedTimeoutException e) {
            if (ast.isAST3()) {
                return ast.arg3();
            }
            return F.Aborted;
        } catch (Exception e) {
            if (Config.DEBUG) {
                e.printStackTrace();
            }
            return F.Null;
        }
    }
}

Example 5 with SimpleTimeLimiter

use of com.google.common.util.concurrent.SimpleTimeLimiter in project eclipse.jdt.ls by eclipse.

the class SignatureHelpRequestor method computeJavaDoc.

public String computeJavaDoc(CompletionProposal proposal) {
    try {
        IType type = unit.getJavaProject().findType(SignatureUtil.stripSignatureToFQN(String.valueOf(proposal.getDeclarationSignature())));
        if (type != null) {
            String[] parameters = Signature.getParameterTypes(String.valueOf(SignatureUtil.fix83600(proposal.getSignature())));
            for (int i = 0; i < parameters.length; i++) {
                parameters[i] = getLowerBound(parameters[i]);
            }
            IMethod method = JavaModelUtil.findMethod(String.valueOf(proposal.getName()), parameters, proposal.isConstructor(), type);
            if (method != null && method.exists()) {
                ICompilationUnit unit = type.getCompilationUnit();
                if (unit != null) {
                    unit.reconcile(ICompilationUnit.NO_AST, false, null, null);
                }
                String javadoc = null;
                try {
                    javadoc = new SimpleTimeLimiter().callWithTimeout(() -> {
                        Reader reader = JavadocContentAccess.getPlainTextContentReader(method);
                        return reader == null ? null : CharStreams.toString(reader);
                    }, 500, TimeUnit.MILLISECONDS, true);
                } catch (UncheckedTimeoutException tooSlow) {
                } catch (Exception e) {
                    JavaLanguageServerPlugin.logException("Unable to read documentation", e);
                }
                return javadoc;
            }
        }
    } catch (JavaModelException e) {
        JavaLanguageServerPlugin.logException("Unable to resolve signaturehelp javadoc", e);
    }
    return null;
}