Examples with TimeoutException java.util.concurrent.TimeoutException used on opensource projects

Example 96 with TimeoutException

use of java.util.concurrent.TimeoutException in project dubbo by alibaba.

the class RpcContext method asyncCall.

/**
     * 异步调用 ，需要返回值，即使步调用Future.get方法，也会处理调用超时问题.
     * @param callable
     * @return 通过future.get()获取返回结果.
     */
@SuppressWarnings("unchecked")
public <T> Future<T> asyncCall(Callable<T> callable) {
    try {
        try {
            setAttachment(Constants.ASYNC_KEY, Boolean.TRUE.toString());
            final T o = callable.call();
            //local调用会直接返回结果.
            if (o != null) {
                FutureTask<T> f = new FutureTask<T>(new Callable<T>() {

                    public T call() throws Exception {
                        return o;
                    }
                });
                f.run();
                return f;
            } else {
            }
        } catch (Exception e) {
            throw new RpcException(e);
        } finally {
            removeAttachment(Constants.ASYNC_KEY);
        }
    } catch (final RpcException e) {
        return new Future<T>() {

            public boolean cancel(boolean mayInterruptIfRunning) {
                return false;
            }

            public boolean isCancelled() {
                return false;
            }

            public boolean isDone() {
                return true;
            }

            public T get() throws InterruptedException, ExecutionException {
                throw new ExecutionException(e.getCause());
            }

            public T get(long timeout, TimeUnit unit) throws InterruptedException, ExecutionException, TimeoutException {
                return get();
            }
        };
    }
    return ((Future<T>) getContext().getFuture());
}

Example 97 with TimeoutException

use of java.util.concurrent.TimeoutException in project dubbo by alibaba.

the class RedisProtocol method refer.

public <T> Invoker<T> refer(final Class<T> type, final URL url) throws RpcException {
    try {
        GenericObjectPool.Config config = new GenericObjectPool.Config();
        config.testOnBorrow = url.getParameter("test.on.borrow", true);
        config.testOnReturn = url.getParameter("test.on.return", false);
        config.testWhileIdle = url.getParameter("test.while.idle", false);
        if (url.getParameter("max.idle", 0) > 0)
            config.maxIdle = url.getParameter("max.idle", 0);
        if (url.getParameter("min.idle", 0) > 0)
            config.minIdle = url.getParameter("min.idle", 0);
        if (url.getParameter("max.active", 0) > 0)
            config.maxActive = url.getParameter("max.active", 0);
        if (url.getParameter("max.wait", 0) > 0)
            config.maxWait = url.getParameter("max.wait", 0);
        if (url.getParameter("num.tests.per.eviction.run", 0) > 0)
            config.numTestsPerEvictionRun = url.getParameter("num.tests.per.eviction.run", 0);
        if (url.getParameter("time.between.eviction.runs.millis", 0) > 0)
            config.timeBetweenEvictionRunsMillis = url.getParameter("time.between.eviction.runs.millis", 0);
        if (url.getParameter("min.evictable.idle.time.millis", 0) > 0)
            config.minEvictableIdleTimeMillis = url.getParameter("min.evictable.idle.time.millis", 0);
        final JedisPool jedisPool = new JedisPool(config, url.getHost(), url.getPort(DEFAULT_PORT), url.getParameter(Constants.TIMEOUT_KEY, Constants.DEFAULT_TIMEOUT));
        final int expiry = url.getParameter("expiry", 0);
        final String get = url.getParameter("get", "get");
        final String set = url.getParameter("set", Map.class.equals(type) ? "put" : "set");
        final String delete = url.getParameter("delete", Map.class.equals(type) ? "remove" : "delete");
        return new AbstractInvoker<T>(type, url) {

            protected Result doInvoke(Invocation invocation) throws Throwable {
                Jedis resource = null;
                try {
                    resource = jedisPool.getResource();
                    if (get.equals(invocation.getMethodName())) {
                        if (invocation.getArguments().length != 1) {
                            throw new IllegalArgumentException("The redis get method arguments mismatch, must only one arguments. interface: " + type.getName() + ", method: " + invocation.getMethodName() + ", url: " + url);
                        }
                        byte[] value = resource.get(String.valueOf(invocation.getArguments()[0]).getBytes());
                        if (value == null) {
                            return new RpcResult();
                        }
                        ObjectInput oin = getSerialization(url).deserialize(url, new ByteArrayInputStream(value));
                        return new RpcResult(oin.readObject());
                    } else if (set.equals(invocation.getMethodName())) {
                        if (invocation.getArguments().length != 2) {
                            throw new IllegalArgumentException("The redis set method arguments mismatch, must be two arguments. interface: " + type.getName() + ", method: " + invocation.getMethodName() + ", url: " + url);
                        }
                        byte[] key = String.valueOf(invocation.getArguments()[0]).getBytes();
                        ByteArrayOutputStream output = new ByteArrayOutputStream();
                        ObjectOutput value = getSerialization(url).serialize(url, output);
                        value.writeObject(invocation.getArguments()[1]);
                        resource.set(key, output.toByteArray());
                        if (expiry > 1000) {
                            resource.expire(key, expiry / 1000);
                        }
                        return new RpcResult();
                    } else if (delete.equals(invocation.getMethodName())) {
                        if (invocation.getArguments().length != 1) {
                            throw new IllegalArgumentException("The redis delete method arguments mismatch, must only one arguments. interface: " + type.getName() + ", method: " + invocation.getMethodName() + ", url: " + url);
                        }
                        resource.del(String.valueOf(invocation.getArguments()[0]).getBytes());
                        return new RpcResult();
                    } else {
                        throw new UnsupportedOperationException("Unsupported method " + invocation.getMethodName() + " in redis service.");
                    }
                } catch (Throwable t) {
                    RpcException re = new RpcException("Failed to invoke redis service method. interface: " + type.getName() + ", method: " + invocation.getMethodName() + ", url: " + url + ", cause: " + t.getMessage(), t);
                    if (t instanceof TimeoutException || t instanceof SocketTimeoutException) {
                        re.setCode(RpcException.TIMEOUT_EXCEPTION);
                    } else if (t instanceof JedisConnectionException || t instanceof IOException) {
                        re.setCode(RpcException.NETWORK_EXCEPTION);
                    } else if (t instanceof JedisDataException) {
                        re.setCode(RpcException.SERIALIZATION_EXCEPTION);
                    }
                    throw re;
                } finally {
                    if (resource != null) {
                        try {
                            jedisPool.returnResource(resource);
                        } catch (Throwable t) {
                            logger.warn("returnResource error: " + t.getMessage(), t);
                        }
                    }
                }
            }

            public void destroy() {
                super.destroy();
                try {
                    jedisPool.destroy();
                } catch (Throwable e) {
                    logger.warn(e.getMessage(), e);
                }
            }
        };
    } catch (Throwable t) {
        throw new RpcException("Failed to refer redis service. interface: " + type.getName() + ", url: " + url + ", cause: " + t.getMessage(), t);
    }
}

Example 98 with TimeoutException

use of java.util.concurrent.TimeoutException in project Smack by igniterealtime.

the class Socks5BytestreamRequest method accept.

/**
     * Accepts the SOCKS5 Bytestream initialization request and returns the socket to send/receive
     * data.
     * <p>
     * Before accepting the SOCKS5 Bytestream request you can set timeouts by invoking
     * {@link #setTotalConnectTimeout(int)} and {@link #setMinimumConnectTimeout(int)}.
     * 
     * @return the socket to send/receive data
     * @throws InterruptedException if the current thread was interrupted while waiting
     * @throws XMPPErrorException 
     * @throws SmackException 
     */
@Override
public Socks5BytestreamSession accept() throws InterruptedException, XMPPErrorException, SmackException {
    Collection<StreamHost> streamHosts = this.bytestreamRequest.getStreamHosts();
    // throw exceptions if request contains no stream hosts
    if (streamHosts.size() == 0) {
        cancelRequest();
    }
    StreamHost selectedHost = null;
    Socket socket = null;
    String digest = Socks5Utils.createDigest(this.bytestreamRequest.getSessionID(), this.bytestreamRequest.getFrom(), this.manager.getConnection().getUser());
    /*
         * determine timeout for each connection attempt; each SOCKS5 proxy has the same amount of
         * time so that the first does not consume the whole timeout
         */
    int timeout = Math.max(getTotalConnectTimeout() / streamHosts.size(), getMinimumConnectTimeout());
    for (StreamHost streamHost : streamHosts) {
        String address = streamHost.getAddress() + ":" + streamHost.getPort();
        // check to see if this address has been blacklisted
        int failures = getConnectionFailures(address);
        if (CONNECTION_FAILURE_THRESHOLD > 0 && failures >= CONNECTION_FAILURE_THRESHOLD) {
            continue;
        }
        // establish socket
        try {
            // build SOCKS5 client
            final Socks5Client socks5Client = new Socks5Client(streamHost, digest);
            // connect to SOCKS5 proxy with a timeout
            socket = socks5Client.getSocket(timeout);
            // set selected host
            selectedHost = streamHost;
            break;
        } catch (TimeoutException | IOException | SmackException | XMPPException e) {
            incrementConnectionFailures(address);
        }
    }
    // throw exception if connecting to all SOCKS5 proxies failed
    if (selectedHost == null || socket == null) {
        cancelRequest();
    }
    // send used-host confirmation
    Bytestream response = createUsedHostResponse(selectedHost);
    this.manager.getConnection().sendStanza(response);
    return new Socks5BytestreamSession(socket, selectedHost.getJID().equals(this.bytestreamRequest.getFrom()));
}

Example 99 with TimeoutException

use of java.util.concurrent.TimeoutException in project Smack by igniterealtime.

the class IncomingFileTransfer method negotiateStream.

private InputStream negotiateStream() throws SmackException, XMPPErrorException, InterruptedException {
    setStatus(Status.negotiating_transfer);
    final StreamNegotiator streamNegotiator = negotiator.selectStreamNegotiator(recieveRequest);
    setStatus(Status.negotiating_stream);
    FutureTask<InputStream> streamNegotiatorTask = new FutureTask<InputStream>(new Callable<InputStream>() {

        @Override
        public InputStream call() throws Exception {
            return streamNegotiator.createIncomingStream(recieveRequest.getStreamInitiation());
        }
    });
    streamNegotiatorTask.run();
    InputStream inputStream;
    try {
        inputStream = streamNegotiatorTask.get(15, TimeUnit.SECONDS);
    } catch (ExecutionException e) {
        final Throwable cause = e.getCause();
        if (cause instanceof XMPPErrorException) {
            throw (XMPPErrorException) cause;
        }
        if (cause instanceof InterruptedException) {
            throw (InterruptedException) cause;
        }
        if (cause instanceof NoResponseException) {
            throw (NoResponseException) cause;
        }
        if (cause instanceof SmackException) {
            throw (SmackException) cause;
        }
        throw new SmackException("Error in execution", e);
    } catch (TimeoutException e) {
        throw new SmackException("Request timed out", e);
    } finally {
        streamNegotiatorTask.cancel(true);
    }
    setStatus(Status.negotiated);
    return inputStream;
}

Example 100 with TimeoutException

use of java.util.concurrent.TimeoutException in project hibernate-orm by hibernate.

the class InvalidationTest method testConcurrentRemoveAndPutFromLoad.

@Test
@TestForIssue(jiraKey = "HHH-9868")
public void testConcurrentRemoveAndPutFromLoad() throws Exception {
    final Item item = new Item("chris", "Chris's Item");
    withTxSession(s -> {
        s.persist(item);
    });
    Phaser deletePhaser = new Phaser(2);
    Phaser getPhaser = new Phaser(2);
    HookInterceptor hook = new HookInterceptor();
    AdvancedCache pendingPutsCache = getPendingPutsCache(Item.class);
    pendingPutsCache.addInterceptor(hook, 0);
    AtomicBoolean getThreadBlockedInDB = new AtomicBoolean(false);
    Thread deleteThread = new Thread(() -> {
        try {
            withTxSession(s -> {
                Item loadedItem = s.get(Item.class, item.getId());
                assertNotNull(loadedItem);
                arriveAndAwait(deletePhaser, 2000);
                arriveAndAwait(deletePhaser, 2000);
                log.trace("Item loaded");
                s.delete(loadedItem);
                s.flush();
                log.trace("Item deleted");
                arriveAndAwait(deletePhaser, 2000);
                arriveAndAwait(deletePhaser, 4000);
            });
        } catch (Exception e) {
            throw new RuntimeException(e);
        }
    }, "delete-thread");
    Thread getThread = new Thread(() -> {
        try {
            withTxSession(s -> {
                Item loadedItem = s.get(Item.class, item.getId());
                if (getThreadBlockedInDB.get()) {
                    assertNull(loadedItem);
                } else {
                    assertNotNull(loadedItem);
                }
            });
        } catch (PessimisticLockException e) {
            // (delete-thread has ITEMS table write-locked and we try to acquire read-lock)
            try {
                arriveAndAwait(getPhaser, 2000);
                arriveAndAwait(getPhaser, 2000);
            } catch (Exception e1) {
                throw new RuntimeException(e1);
            }
        } catch (Exception e) {
            throw new RuntimeException(e);
        }
    }, "get-thread");
    deleteThread.start();
    // deleteThread loads the entity
    arriveAndAwait(deletePhaser, 2000);
    withTx(() -> {
        sessionFactory().getCache().evictEntity(Item.class, item.getId());
        assertFalse(sessionFactory().getCache().containsEntity(Item.class, item.getId()));
        return null;
    });
    arriveAndAwait(deletePhaser, 2000);
    // delete thread invalidates PFER
    arriveAndAwait(deletePhaser, 2000);
    // get thread gets the entity from DB
    hook.block(getPhaser, getThread);
    getThread.start();
    try {
        arriveAndAwait(getPhaser, 2000);
    } catch (TimeoutException e) {
        getThreadBlockedInDB.set(true);
    }
    arriveAndAwait(deletePhaser, 2000);
    // delete thread finishes the remove from DB and cache
    deleteThread.join();
    hook.unblock();
    arriveAndAwait(getPhaser, 2000);
    // get thread puts the entry into cache
    getThread.join();
    assertNoInvalidators(pendingPutsCache);
    withTxSession(s -> {
        Item loadedItem = s.get(Item.class, item.getId());
        assertNull(loadedItem);
    });
}