Example usage for io.netty.channel ChannelFuture awaitUninterruptibly

List of usage examples for io.netty.channel ChannelFuture awaitUninterruptibly

  1. HOME
  2. Java
  3. io.netty
  4. io.netty.channel.*
  5. ChannelFuture
  6. awaitUninterruptibly

Introduction

In this page you can find the example usage for io.netty.channel ChannelFuture awaitUninterruptibly.

Prototype

boolean awaitUninterruptibly(long timeout, TimeUnit unit);

Source Link

Document

Waits for this future to be completed within the specified time limit without interruption.

Usage

From source file:ccwihr.client.t2.HttpResponseHandler.java

License:Apache License

/**
 * Wait (sequentially) for a time duration for each anticipated response
 *
 * @param timeout Value of time to wait for each response
 * @param unit Units associated with {@code timeout}
 * @see HttpResponseHandler#put(int, io.netty.channel.ChannelFuture, io.netty.channel.ChannelPromise)
 *///from w  ww . ja  va 2  s .c  o m
public void awaitResponses(long timeout, TimeUnit unit) {
    Iterator<Entry<Integer, Entry<ChannelFuture, ChannelPromise>>> itr = streamidPromiseMap.entrySet()
            .iterator();
    while (itr.hasNext()) {
        Entry<Integer, Entry<ChannelFuture, ChannelPromise>> entry = itr.next();
        ChannelFuture writeFuture = entry.getValue().getKey();
        if (!writeFuture.awaitUninterruptibly(timeout, unit)) {
            throw new IllegalStateException("Timed out waiting to write for stream id " + entry.getKey());
        }
        if (!writeFuture.isSuccess()) {
            throw new RuntimeException(writeFuture.cause());
        }
        ChannelPromise promise = entry.getValue().getValue();
        if (!promise.awaitUninterruptibly(timeout, unit)) {
            throw new IllegalStateException("Timed out waiting for response on stream id " + entry.getKey());
        }
        if (!promise.isSuccess()) {
            throw new RuntimeException(promise.cause());
        }
        System.out.println("---Stream id: " + entry.getKey() + " received---");
        itr.remove();
    }
}

From source file:cn.jpush.api.common.connection.HttpResponseHandler.java

License:Apache License

/**
 * Wait (sequentially) for a time duration for each anticipated response
 *
 * @param timeout Value of time to wait for each response
 * @param unit Units associated with {@code timeout}
 * @see HttpResponseHandler#put(int, ChannelFuture, ChannelPromise)
 *//*from   w  w  w .  jav  a 2s. c o m*/
public void awaitResponses(long timeout, TimeUnit unit) {
    Iterator<Entry<Integer, Entry<ChannelFuture, ChannelPromise>>> itr = streamidPromiseMap.entrySet()
            .iterator();
    while (itr.hasNext()) {
        Entry<Integer, Entry<ChannelFuture, ChannelPromise>> entry = itr.next();
        ChannelFuture writeFuture = entry.getValue().getKey();
        if (!writeFuture.awaitUninterruptibly(timeout, unit)) {
            throw new IllegalStateException("Timed out waiting to write for stream id " + entry.getKey());
        }
        if (!writeFuture.isSuccess()) {
            throw new RuntimeException(writeFuture.cause());
        }
        ChannelPromise promise = entry.getValue().getValue();
        if (!promise.awaitUninterruptibly(timeout, unit)) {
            throw new IllegalStateException("Timed out waiting for response on stream id " + entry.getKey());
        }
        if (!promise.isSuccess()) {
            throw new RuntimeException(promise.cause());
        }
        System.out.println("---Stream id: " + entry.getKey() + " received---");
        System.out.println("---Stream id: " + promise.toString());
        itr.remove();
    }
}

From source file:com.alibaba.dubbo.remoting.transport.netty.NettyClient.java

License:Apache License

protected void doConnect() throws Throwable {
    long start = System.currentTimeMillis();
    ChannelFuture future = bootstrap.connect(getConnectAddress());
    try {//from w w  w  .  j a v  a 2 s  .  co m
        boolean ret = future.awaitUninterruptibly(3000, TimeUnit.MILLISECONDS);

        if (ret && future.isSuccess()) {
            Channel newChannel = future.channel();
            try {
                // 
                Channel oldChannel = NettyClient.this.channel; // copy reference
                if (oldChannel != null) {
                    try {
                        if (logger.isInfoEnabled()) {
                            logger.info("Close old netty channel " + oldChannel
                                    + " on create new netty channel " + newChannel);
                        }
                        oldChannel.close();
                    } finally {
                        NettyChannel.removeChannelIfDisconnected(oldChannel);
                    }
                }
            } finally {
                if (NettyClient.this.isClosed()) {
                    try {
                        if (logger.isInfoEnabled()) {
                            logger.info(
                                    "Close new netty channel " + newChannel + ", because the client closed.");
                        }
                        newChannel.close();
                    } finally {
                        NettyClient.this.channel = null;
                        NettyChannel.removeChannelIfDisconnected(newChannel);
                    }
                } else {
                    NettyClient.this.channel = newChannel;
                }
            }
        } else if (future.cause() != null) {
            throw new RemotingException(this, "client(url: " + getUrl() + ") failed to connect to server "
                    + getRemoteAddress() + ", error message is:" + future.cause().getMessage(), future.cause());
        } else {
            throw new RemotingException(this,
                    "client(url: " + getUrl() + ") failed to connect to server " + getRemoteAddress()
                            + " client-side timeout " + getConnectTimeout() + "ms (elapsed: "
                            + (System.currentTimeMillis() - start) + "ms) from netty client "
                            + NetUtils.getLocalHost() + " using dubbo version " + Version.getVersion());
        }
    } finally {
        if (!isConnected()) {
            //future.cancel(true);
        }
    }
}

From source file:com.ning.http.client.providers.netty_4.NettyAsyncHttpProvider.java

License:Apache License

private <T> ListenableFuture<T> doConnect(final Request request, final AsyncHandler<T> asyncHandler,
        NettyResponseFuture<T> f, boolean useCache, boolean asyncConnect, boolean reclaimCache)
        throws IOException {

    if (isClose.get()) {
        throw new IOException("Closed");
    }//from  ww w .jav  a2 s .  co  m

    if (request.getUrl().startsWith(WEBSOCKET) && !validateWebSocketRequest(request, asyncHandler)) {
        throw new IOException("WebSocket method must be a GET");
    }

    ProxyServer proxyServer = ProxyUtils.getProxyServer(config, request);
    boolean useProxy = proxyServer != null;
    URI uri;
    if (useRawUrl) {
        uri = request.getRawURI();
    } else {
        uri = request.getURI();
    }
    Channel channel = null;

    if (useCache) {
        if (f != null && f.reuseChannel() && f.channel() != null) {
            channel = f.channel();
        } else {
            URI connectionKeyUri = useProxy ? proxyServer.getURI() : uri;
            channel = lookupInCache(connectionKeyUri, request.getConnectionPoolKeyStrategy());
        }
    }

    ByteBuf bufferedBytes = null;
    if (f != null && f.getRequest().getFile() == null
            && !f.getNettyRequest().getMethod().name().equals(HttpMethod.CONNECT.name())) {
        bufferedBytes = f.getNettyRequest().data();
    }

    boolean useSSl = isSecure(uri) && !useProxy;
    if (channel != null && channel.isOpen() && channel.isActive()) {
        HttpRequest nettyRequest = buildRequest(config, request, uri, f == null ? false : f.isConnectAllowed(),
                bufferedBytes, proxyServer);

        if (f == null) {
            f = newFuture(uri, request, asyncHandler, nettyRequest, config, this, proxyServer);
        } else {
            nettyRequest = buildRequest(config, request, uri, f.isConnectAllowed(), bufferedBytes, proxyServer);
            f.setNettyRequest(nettyRequest);
        }
        f.setState(NettyResponseFuture.STATE.POOLED);
        f.attachChannel(channel, false);

        log.debug("\nUsing cached Channel {}\n for request \n{}\n", channel, nettyRequest);
        channel.pipeline().context(NettyAsyncHttpProvider.class).attr(DEFAULT_ATTRIBUTE).set(f);

        try {
            writeRequest(channel, config, f, nettyRequest);
        } catch (Exception ex) {
            log.debug("writeRequest failure", ex);
            if (useSSl && ex.getMessage() != null && ex.getMessage().contains("SSLEngine")) {
                log.debug("SSLEngine failure", ex);
                f = null;
            } else {
                try {
                    asyncHandler.onThrowable(ex);
                } catch (Throwable t) {
                    log.warn("doConnect.writeRequest()", t);
                }
                IOException ioe = new IOException(ex.getMessage());
                ioe.initCause(ex);
                throw ioe;
            }
        }
        return f;
    }

    // Do not throw an exception when we need an extra connection for a redirect.
    if (!reclaimCache && !connectionsPool.canCacheConnection()) {
        IOException ex = new IOException("Too many connections " + config.getMaxTotalConnections());
        try {
            asyncHandler.onThrowable(ex);
        } catch (Throwable t) {
            log.warn("!connectionsPool.canCacheConnection()", t);
        }
        throw ex;
    }

    boolean acquiredConnection = false;

    if (trackConnections) {
        if (!reclaimCache) {
            if (!freeConnections.tryAcquire()) {
                IOException ex = new IOException("Too many connections " + config.getMaxTotalConnections());
                try {
                    asyncHandler.onThrowable(ex);
                } catch (Throwable t) {
                    log.warn("!connectionsPool.canCacheConnection()", t);
                }
                throw ex;
            } else {
                acquiredConnection = true;
            }
        }
    }

    NettyConnectListener<T> c = new NettyConnectListener.Builder<T>(config, request, asyncHandler, f, this,
            bufferedBytes).build(uri);
    boolean avoidProxy = ProxyUtils.avoidProxy(proxyServer, uri.getHost());

    if (useSSl) {
        constructSSLPipeline(c);
    }

    ChannelFuture channelFuture;
    Bootstrap bootstrap = request.getUrl().startsWith(WEBSOCKET)
            ? (useSSl ? secureWebSocketBootstrap : webSocketBootstrap)
            : (useSSl ? secureBootstrap : plainBootstrap);
    bootstrap.option(ChannelOption.CONNECT_TIMEOUT_MILLIS, config.getConnectionTimeoutInMs());

    try {
        InetSocketAddress remoteAddress;
        if (request.getInetAddress() != null) {
            remoteAddress = new InetSocketAddress(request.getInetAddress(),
                    AsyncHttpProviderUtils.getPort(uri));
        } else if (proxyServer == null || avoidProxy) {
            remoteAddress = new InetSocketAddress(AsyncHttpProviderUtils.getHost(uri),
                    AsyncHttpProviderUtils.getPort(uri));
        } else {
            remoteAddress = new InetSocketAddress(proxyServer.getHost(), proxyServer.getPort());
        }

        if (request.getLocalAddress() != null) {
            channelFuture = bootstrap.connect(remoteAddress,
                    new InetSocketAddress(request.getLocalAddress(), 0));
        } else {
            channelFuture = bootstrap.connect(remoteAddress);
        }

    } catch (Throwable t) {
        if (acquiredConnection) {
            freeConnections.release();
        }
        abort(c.future(), t.getCause() == null ? t : t.getCause());
        return c.future();
    }

    boolean directInvokation = true;
    if (IN_IO_THREAD.get() && DefaultChannelFuture.isUseDeadLockChecker()) {
        directInvokation = false;
    }

    if (directInvokation && !asyncConnect && request.getFile() == null) {
        int timeOut = config.getConnectionTimeoutInMs() > 0 ? config.getConnectionTimeoutInMs()
                : Integer.MAX_VALUE;
        if (!channelFuture.awaitUninterruptibly(timeOut, TimeUnit.MILLISECONDS)) {
            if (acquiredConnection) {
                freeConnections.release();
            }
            channelFuture.cancel();
            abort(c.future(),
                    new ConnectException(String.format("Connect operation to %s timeout %s", uri, timeOut)));
        }

        try {
            c.operationComplete(channelFuture);
        } catch (Exception e) {
            if (acquiredConnection) {
                freeConnections.release();
            }
            IOException ioe = new IOException(e.getMessage());
            ioe.initCause(e);
            try {
                asyncHandler.onThrowable(ioe);
            } catch (Throwable t) {
                log.warn("c.operationComplete()", t);
            }
            throw ioe;
        }
    } else {
        channelFuture.addListener(c);
    }

    log.debug("\nNon cached request \n{}\n\nusing Channel \n{}\n", c.future().getNettyRequest(),
            channelFuture.getChannel());

    if (!c.future().isCancelled() || !c.future().isDone()) {
        openChannels.add(channelFuture.channel());
        c.future().attachChannel(channelFuture.channel(), false);
    }
    return c.future();
}

From source file:com.weibo.api.motan.transport.netty.NettyChannel.java

License:Apache License

@Override
public Response request(Request request) throws TransportException {
    int timeout = nettyClient.getUrl().getMethodParameter(request.getMethodName(), request.getParamtersDesc(),
            URLParamType.requestTimeout.getName(), URLParamType.requestTimeout.getIntValue());
    if (timeout <= 0) {
        throw new MotanFrameworkException("NettyClient init Error: timeout(" + timeout + ") <= 0 is forbid.",
                MotanErrorMsgConstant.FRAMEWORK_INIT_ERROR);
    }/*w  w w .ja v a 2s .co m*/
    NettyResponseFuture response = new NettyResponseFuture(request, timeout, this.nettyClient);
    this.nettyClient.registerCallback(request.getRequestId(), response);

    ChannelFuture writeFuture = this.channel.writeAndFlush(request);

    boolean result = writeFuture.awaitUninterruptibly(timeout, TimeUnit.MILLISECONDS);

    if (result && writeFuture.isSuccess()) {
        response.addListener(new FutureListener() {
            @Override
            public void operationComplete(Future future) throws Exception {
                if (future.isSuccess()
                        || (future.isDone() && ExceptionUtil.isBizException(future.getException()))) {
                    // ? 
                    nettyClient.resetErrorCount();
                } else {
                    //  
                    nettyClient.incrErrorCount();
                }
            }
        });
        return response;
    }

    writeFuture.cancel(false);
    response = this.nettyClient.removeCallback(request.getRequestId());

    if (response != null) {
        response.cancel();
    }

    //  
    nettyClient.incrErrorCount();

    if (writeFuture.cause() != null) {
        throw new MotanServiceException(
                "NettyChannel send request to server Error: url=" + nettyClient.getUrl().getUri() + " local="
                        + localAddress + " " + MotanFrameworkUtil.toString(request),
                writeFuture.cause());
    } else {
        throw new MotanServiceException(
                "NettyChannel send request to server Timeout: url=" + nettyClient.getUrl().getUri() + " local="
                        + localAddress + " " + MotanFrameworkUtil.toString(request));
    }
}

From source file:com.weibo.api.motan.transport.netty.NettyChannel.java

License:Apache License

@Override
public synchronized boolean open() {
    if (isAvailable()) {
        LoggerUtil.warn("the channel already open, local: " + localAddress + " remote: " + remoteAddress
                + " url: " + nettyClient.getUrl().getUri());
        return true;
    }/*from   w  ww .j a  v a  2  s  .  c  o m*/

    try {
        ChannelFuture channleFuture = nettyClient.getBootstrap()
                .connect(new InetSocketAddress(nettyClient.getUrl().getHost(), nettyClient.getUrl().getPort()));

        long start = System.currentTimeMillis();

        int timeout = nettyClient.getUrl().getIntParameter(URLParamType.connectTimeout.getName(),
                URLParamType.connectTimeout.getIntValue());
        if (timeout <= 0) {
            throw new MotanFrameworkException(
                    "NettyClient init Error: timeout(" + timeout + ") <= 0 is forbid.",
                    MotanErrorMsgConstant.FRAMEWORK_INIT_ERROR);
        }
        // ??connectTimeout
        boolean result = channleFuture.awaitUninterruptibly(timeout, TimeUnit.MILLISECONDS);
        boolean success = channleFuture.isSuccess();

        if (result && success) {
            channel = channleFuture.channel();
            if (channel.localAddress() != null && channel.localAddress() instanceof InetSocketAddress) {
                localAddress = (InetSocketAddress) channel.localAddress();
            }

            state = ChannelState.ALIVE;
            return true;
        }
        boolean connected = false;
        if (channleFuture.channel() != null) {
            connected = channleFuture.channel().isActive();
        }

        if (channleFuture.cause() != null) {
            channleFuture.cancel(false);
            throw new MotanServiceException(
                    "NettyChannel failed to connect to server, url: " + nettyClient.getUrl().getUri()
                            + ", result: " + result + ", success: " + success + ", connected: " + connected,
                    channleFuture.cause());
        } else {
            channleFuture.cancel(false);
            throw new MotanServiceException("NettyChannel connect to server timeout url: "
                    + nettyClient.getUrl().getUri() + ", cost: " + (System.currentTimeMillis() - start)
                    + ", result: " + result + ", success: " + success + ", connected: " + connected);
        }
    } catch (MotanServiceException e) {
        throw e;
    } catch (Exception e) {
        throw new MotanServiceException(
                "NettyChannel failed to connect to server, url: " + nettyClient.getUrl().getUri(), e);
    } finally {
        if (!state.isAliveState()) {
            nettyClient.incrErrorCount();
        }
    }
}

From source file:com.weibo.api.motan.transport.netty4.client.NettyChannel.java

License:Apache License

@Override
public Response request(Request request) throws TransportException {
    int timeout = nettyClient.getUrl().getMethodParameter(request.getMethodName(), request.getParamtersDesc(),
            URLParamType.requestTimeout.getName(), URLParamType.requestTimeout.getIntValue());
    if (timeout <= 0) {
        throw new MotanFrameworkException("Netty4Client init Error: timeout(" + timeout + ") <= 0 is forbid.",
                MotanErrorMsgConstant.FRAMEWORK_INIT_ERROR);
    }//from w  ww.  ja v  a  2  s. co  m
    NettyResponseFuture response = new NettyResponseFuture(request, timeout, this.nettyClient);
    this.nettyClient.registerCallback(request.getRequestId(), response);

    ChannelFuture writeFuture = this.channel.writeAndFlush(request);

    boolean result = writeFuture.awaitUninterruptibly(timeout, TimeUnit.SECONDS);

    if (result && writeFuture.isSuccess()) {
        response.addListener(new FutureListener() {
            @Override
            public void operationComplete(Future future) throws Exception {
                if (future.isSuccess()
                        || (future.isDone() && ExceptionUtil.isBizException(future.getException()))) {
                    // ? 
                    nettyClient.resetErrorCount();
                } else {
                    //  
                    nettyClient.incrErrorCount();
                }
            }
        });
        return response;
    }

    writeFuture.cancel(true);
    response = this.nettyClient.removeCallback(request.getRequestId());

    if (response != null) {
        response.cancel();
    }

    //  
    nettyClient.incrErrorCount();

    if (writeFuture.cause() != null) {
        throw new MotanServiceException(
                "NettyChannel send request to server Error: url=" + nettyClient.getUrl().getUri() + " local="
                        + localAddress + " " + MotanFrameworkUtil.toString(request),
                writeFuture.cause());
    } else {
        throw new MotanServiceException(
                "NettyChannel send request to server Timeout: url=" + nettyClient.getUrl().getUri() + " local="
                        + localAddress + " " + MotanFrameworkUtil.toString(request));
    }
}

From source file:com.weibo.api.motan.transport.netty4.client.NettyChannel.java

License:Apache License

@Override
public synchronized boolean open() {
    if (isAvailable()) {
        LoggerUtil.warn("the channel already open, local: " + localAddress + " remote: " + remoteAddress
                + " url: " + nettyClient.getUrl().getUri());
        return true;
    }/*from   ww w  .  j a  v a 2s  . c  o m*/

    try {
        ChannelFuture channelFuture = nettyClient.getBootstrap()
                .connect(new InetSocketAddress(nettyClient.getUrl().getHost(), nettyClient.getUrl().getPort()));

        long start = System.currentTimeMillis();

        int timeout = nettyClient.getUrl().getIntParameter(URLParamType.connectTimeout.getName(),
                URLParamType.connectTimeout.getIntValue());
        if (timeout <= 0) {
            throw new MotanFrameworkException(
                    "Netty4Client init Error: timeout(" + timeout + ") <= 0 is forbid.",
                    MotanErrorMsgConstant.FRAMEWORK_INIT_ERROR);
        }
        // ??connectTimeout
        boolean result = channelFuture.awaitUninterruptibly(timeout, TimeUnit.MILLISECONDS);
        boolean success = channelFuture.isSuccess();

        if (result && success) {
            channel = channelFuture.channel();
            if (channel.localAddress() != null && channel.localAddress() instanceof InetSocketAddress) {
                localAddress = (InetSocketAddress) channel.localAddress();
            }

            state = ChannelState.ALIVE;
            return true;
        }
        boolean connected = false;
        if (channelFuture.channel() != null) {
            connected = channelFuture.channel().isOpen();
        }

        if (channelFuture.cause() != null) {
            channelFuture.cancel(true);
            throw new MotanServiceException(
                    "NettyChannel failed to connect to server, url: " + nettyClient.getUrl().getUri()
                            + ", result: " + result + ", success: " + success + ", connected: " + connected,
                    channelFuture.cause());
        } else {
            channelFuture.cancel(true);
            throw new MotanServiceException("NettyChannel connect to server timeout url: "
                    + nettyClient.getUrl().getUri() + ", cost: " + (System.currentTimeMillis() - start)
                    + ", result: " + result + ", success: " + success + ", connected: " + connected);
        }
    } catch (MotanServiceException e) {
        throw e;
    } catch (Exception e) {
        throw new MotanServiceException(
                "NettyChannel failed to connect to server, url: " + nettyClient.getUrl().getUri(), e);
    } finally {
        if (!state.isAliveState()) {
            nettyClient.incrErrorCount();
        }
    }
}

From source file:http.HTTPResponseHandler.java

License:Open Source License

/**
 * Provide asynchronous response to HTTP2 request
 *
 * @param streamId StreamID/*w  w  w.ja  v a  2  s  .  c o m*/
 * @return Response string
 */
public String getResponse(int streamId) {

    String message = streamIdResponseMap.get(streamId);
    if (message != null) {
        return message;
    } else {
        Entry<ChannelFuture, ChannelPromise> channelFutureChannelPromiseEntry = streamIdPromiseMap
                .get(streamId);
        if (channelFutureChannelPromiseEntry != null) {
            ChannelFuture writeFuture = channelFutureChannelPromiseEntry.getKey();
            if (!writeFuture.awaitUninterruptibly(ServerUtil.HTTP2_RESPONSE_TIME_OUT,
                    ServerUtil.HTTP2_RESPONSE_TIME_UNIT)) {
                streamIdPromiseMap.remove(streamId);
                throw new IllegalStateException("Timed out waiting to write for stream id " + streamId);
            }
            if (!writeFuture.isSuccess()) {
                streamIdPromiseMap.remove(streamId);
                throw new RuntimeException(writeFuture.cause());
            }
            ChannelPromise promise = channelFutureChannelPromiseEntry.getValue();
            if (!promise.awaitUninterruptibly(ServerUtil.HTTP2_RESPONSE_TIME_OUT,
                    ServerUtil.HTTP2_RESPONSE_TIME_UNIT)) {
                streamIdPromiseMap.remove(streamId);
                throw new IllegalStateException("Timed out waiting for response on stream id " + streamId);
            }
            if (!promise.isSuccess()) {
                streamIdPromiseMap.remove(streamId);
                throw new RuntimeException(promise.cause());
            }
        }
    }
    return streamIdResponseMap.get(streamId);
}

From source file:http2.client.HttpResponseHandler.java

License:Apache License

/**
 * anticipated : ?//from   w w  w. j  a  v  a  2s  . co m
 * Wait (sequentially) for a time duration for each anticipated response
 *
 * @param timeout Value of time to wait for each response
 * @param unit Units associated with {@code timeout}
 * @see HttpResponseHandler#put(int, ChannelFuture, ChannelPromise)
 */
public void awaitResponses(long timeout, TimeUnit unit) {
    Iterator<Entry<Integer, Entry<ChannelFuture, ChannelPromise>>> itr = streamidPromiseMap.entrySet()
            .iterator();
    while (itr.hasNext()) {
        Entry<Integer, Entry<ChannelFuture, ChannelPromise>> entry = itr.next();
        ChannelFuture writeFuture = entry.getValue().getKey();
        //
        if (!writeFuture.awaitUninterruptibly(timeout, unit)) {
            throw new IllegalStateException("Timed out waiting to write for stream id " + entry.getKey());
        }
        //
        if (!writeFuture.isSuccess()) {
            throw new RuntimeException(writeFuture.cause());
        }
        //
        ChannelPromise promise = entry.getValue().getValue();
        if (!promise.awaitUninterruptibly(timeout, unit)) {
            throw new IllegalStateException("Timed out waiting for response on stream id " + entry.getKey());
        }
        if (!promise.isSuccess()) {
            throw new RuntimeException(promise.cause());
        }
        System.out.println("---Stream id: " + entry.getKey() + " received---");
        itr.remove();
    }
}