return;

            final long timeoutNanos = NANOSECONDS.convert(getTimeout(), MILLISECONDS);

            for (Iterator<Message> it = sentPacket.reverseIterator(); it.hasNext();) {

                        continue;

                    if (message instanceof LineMessage) {

                        LOG.debug("Timeout on message {}", message);

                        received.add(Message.TIMEOUT((LineMessage) message).setIncoming());

                    }

            // as I see it, the only way to truly resolve it is to have multi-part packets, but we don't want to do that.

            // what we do is that we don't allow a packet with requests only to be full - we always leave room for a response.

            // assumes hasRequests and requestsOnly are up to date.

            overflow = null;

            if (next == null)

                next = queue.poll();

            for (;;) {

                if (next == null)

                    break;

                overflow = next; // we put the next message into overflow. if we _don't_ break out of the loop and use the message, we'll nul overflow

                    break; // we're not taking any non-broadcast messages during broadcast

                    if (sentPacket == null || sentPacket.isEmpty()) {

                        LOG.debug("Node peer {} going into broadcast mode for message {}.", this, next);

                        broadcast = true;

                    }

                    // else, we add message to packet, and continue transmitting.

                    // if the packet had responses only, the new broadcast request would force a re-send and expedite matters

                    // if a response for the broadcast is received before we get a chance to multicast, that's ok because we simply remove the node

                    // from the BroadcastEntry

                }

                    LOG.error("Message {} is larger than the maximum packet size {}", next, maxPacketSize);

                    throw new RuntimeException("Message is larger than maxPacketSize");

                }

                        LOG.warn("IMPORTANT: Response message {} does not fit in packet {} which contains only requests. THIS MAY CAUSE A DEADLOCK!", next, sentPacket);

                    break;

                }

                        break;

                    hasRequests = true;

                } else

                    requestsOnly = false;

                LOG.debug("Adding message {} to sent-packet", next);

                if (sentPacket == null)

                    sentPacket = new MessagePacket();

                sentPacket.addMessage(next);

            return null;

        }

        private void handleQueue(long start) throws InterruptedException {

            overflow = null;

            if (next == null)

                next = queue.poll();

            loop:

            for (;;) {

                if (next == null)

                    break;

                overflow = next; // we put the next message into overflow. if we _don't_ break out of the loop and use the message, we'll nul overflow

                    LOG.error("Message {} is larger than the maximum packet size {}", next, maxPacketSize);

                    throw new RuntimeException("Message is larger than maxPacketSize");

                }

                    break;

                LOG.debug("Waiting for peers to enter broadcast mode for message {}", next);

                if (entry != null) {

                    if (entry.nodes.isEmpty()) {

                        if (next instanceof LineMessage) {

                            LOG.debug("No other nodes in cluster. Responding with NOT_FOUND to message {}", next);

                            receive(Message.NOT_FOUND((LineMessage) next).setIncoming());

                        }

                        entry = null;

                    }

                }

                if (entry != null) {

                    for (TShortIterator it = entry.nodes.iterator(); it.hasNext();) {

                        final short node = it.next();

                        final NodePeer peer = peers.get(node);

                        synchronized (peer) {

                                LOG.trace("Waiting for peer {}.", peer);

                                break loop;

                            }

                            LOG.trace("Peer {} ok (broadcast {})", peer, next);

                        }

            final long timeoutNanos = NANOSECONDS.convert(getTimeout(), MILLISECONDS);

            for (Iterator<BroadcastEntry> it = broadcasts.values().iterator(); it.hasNext();) {

                final BroadcastEntry entry = it.next();

                    if (message instanceof LineMessage) {

                        LOG.debug("Timeout on message {}", message);

                        received.add(Message.TIMEOUT((LineMessage) message).setIncoming());

                    }

                    it.remove();

                    releasePeers(entry, (short) -1);

                    addTimeout(message);

                    if (sentPacket != null)

                }

            }

            if (sentPacket != null && sentPacket.isEmpty())

                sentPacket = null;

            }

        }

        private void releasePeers(BroadcastEntry entry, short node) {

            for (TShortIterator it = entry.nodes.iterator(); it.hasNext();) {

                final NodePeer peer = peers.get(it.next());

                if (peer.isBroadcast()) {

                    LOG.debug("Broadcast releasing peer {} for message {}", peer, message);

                    if (peer.node != node) {