final Queue<Pooled<ByteBuffer>> queue = this.queue; synchronized (this) { while (queue.isEmpty()) { if (eof) { return -1; final Pooled<ByteBuffer> entry = queue.peek(); final ByteBuffer buf = entry.getResource(); final int v = buf.get() & 0xff; if (buf.remaining() == 0) { queue.poll(); try { inputHandler.acknowledge(entry); entry.free();
public void discard() { if (freedUpdater.compareAndSet(this, 0, 1)) { zero(allocated.getResource()); allocated.discard(); } }
protected void onFullCloseMessage(final WebSocketChannel channel, BufferedBinaryMessage message) throws IOException { Pooled<ByteBuffer[]> data = message.getData(); try { CloseMessage cm = new CloseMessage(data.getResource()); onCloseMessage(cm, channel); if (!channel.isCloseFrameSent()) { WebSockets.sendClose(cm, channel, null); } } finally { data.close(); } }
public void free() { if (freedUpdater.compareAndSet(this, 0, 1)) { zero(allocated.getResource()); allocated.free(); } }
/** * Push a buffer into the queue. There is no mechanism to limit the number of pushed buffers; if such a mechanism * is desired, it must be implemented externally, for example maybe using a {@link Semaphore}. * * @param pooledBuffer the buffer from which more data should be read */ public void push(final Pooled<ByteBuffer> pooledBuffer) { synchronized (this) { if (pooledBuffer.getResource().hasRemaining() && !eof && failure == null) { queue.add(pooledBuffer); notifyAll(); } else { pooledBuffer.free(); } } }
XnioExecutor.Key heartKey1 = RemoteWriteListener.this.heartKey; if (heartKey1 != null) heartKey1.remove(); if (closed) { pooled.free(); return; } if (close) { closed = true; } boolean free = true; final SaslWrapper wrapper = saslWrapper; if (wrapper != null) { final ByteBuffer buffer = pooled.getResource(); final ByteBuffer source = buffer.duplicate(); buffer.clear(); buffer.flip(); final boolean empty = queue.isEmpty(); queue.add(pooled); free = false; if (empty) { handleException(e, false); Pooled<ByteBuffer> unqueued; while ((unqueued = queue.poll()) != null) { unqueued.free(); pooled.free();
public void shutdownWrites() { synchronized (queue) { closed = true; terminateHeartbeat(); final ConduitStreamSinkChannel sinkChannel = connection.getSinkChannel(); try { if (! queue.isEmpty()) { sinkChannel.resumeWrites(); return; } sinkChannel.shutdownWrites(); if (! sinkChannel.flush()) { sinkChannel.resumeWrites(); return; } Messages.conn.logf(FQCN, Logger.Level.TRACE, null, "Shut down writes on channel"); } catch (IOException e) { handleException(e, false); Pooled<ByteBuffer> unqueued; while ((unqueued = queue.poll()) != null) { unqueued.free(); } } } }
boolean free = true; try { final ByteBuffer buffer = allocated.getResource(); long transferred; for(;;) { try { transferred = source.transferTo(count, buffer, sink); } catch (IOException e) { invokeChannelExceptionHandler(source, readExceptionHandler, e); return; sink.suspendWrites(); } else { sink.wakeupWrites(); source.suspendReads(); sink.suspendWrites(); invokeChannelExceptionHandler(source, readExceptionHandler, new EOFException()); res = sink.write(buffer); } catch (IOException e) { invokeChannelExceptionHandler(sink, writeExceptionHandler, e); return; return; } finally { if (free) allocated.free();
public void handleEvent(final Channel channel) { final ByteBuffer buffer = pooledBuffer.getResource(); int state = this.state; boolean needsFlush = false; try { lres = source.transferTo(count, buffer, sink); } catch (IOException e) { readFailed(e); source.resumeReads(); return; while (buffer.hasRemaining()) { try { ires = sink.write(buffer); } catch (IOException e) { writeFailed(e); source.suspendReads(); .set(ChannelListeners.flushingChannelListener(this, new ChannelExceptionHandler<Channel>() { @Override .set(ChannelListeners.flushingChannelListener(this, new ChannelExceptionHandler<Channel>() { @Override
private void readFailed(final IOException e) { try { source.suspendReads(); sink.suspendWrites(); invokeChannelExceptionHandler(source, readExceptionHandler, e); } finally { pooledBuffer.free(); } }
public void handleEvent(final Channel channel) { final ByteBuffer buffer = pooledBuffer.getResource(); int state = this.state; lres = source.transferTo(count, buffer, sink); } catch (IOException e) { readFailed(e); ires = sink.write(buffer); } catch (IOException e) { writeFailed(e); this.count = count; this.state = 1; source.suspendReads(); sink.resumeWrites(); return; while (buffer.hasRemaining()) { try { ires = sink.write(buffer); } catch (IOException e) { writeFailed(e); lres = source.transferTo(count, buffer, sink); } catch (IOException e) { readFailed(e);
private void done() { try { final ChannelListener<? super I> sourceListener = this.sourceListener; final ChannelListener<? super O> sinkListener = this.sinkListener; final I source = this.source; final O sink = this.sink; Channels.setReadListener(source, sourceListener); if (sourceListener == null) { source.suspendReads(); } else { source.wakeupReads(); } Channels.setWriteListener(sink, sinkListener); if (sinkListener == null) { sink.suspendWrites(); } else { sink.wakeupWrites(); } } finally { pooledBuffer.free(); } }
public long read(final ByteBuffer[] dsts, final int offs, final int len) throws IOException { final int state = this.state; if (anyAreSet(state, READ_FLAG_SHUTDOWN)) { return -1; } else if (anyAreSet(state, READ_FLAG_EOF)){ if (readBuffer.getResource().position() > 0) { final ByteBuffer readBufferResource = readBuffer.getResource(); readBufferResource.flip(); try { } else if (allAreClear(state, FLAG_TLS)) { long res = sourceConduit.read(dsts, offs, len); if (res == 0) {
final ByteBuffer src; try { src = buffer.getResource(); final int pos = src.position(); final int rem = src.remaining(); return target.write(src); } finally { src.limit(pos + rem); } else { cnt = target.write(src); if (cnt == rem) { buffer.free(); } else { return cnt; cnt = 0L; final long res = next.transferTo(count - cnt, throughBuffer, target); return res > 0L ? cnt + res : cnt > 0L ? cnt : res;
public long read(final ByteBuffer[] dsts, final int offset, final int length) throws IOException { long cnt; try { final ByteBuffer src = buffer.getResource(); cnt = Buffers.copy(dsts, offset, length, src); if (src.hasRemaining()) { return cnt; } final StreamSourceChannel next = channel = this.next; buffer.free(); if (cnt > 0L && next == firstChannel) { // don't hit the main channel until the user wants to return cnt; } } catch (IllegalStateException ignored) { channel = next; cnt = 0; } final long res = next.read(dsts, offset, length); return res > 0 ? res + cnt : cnt > 0 ? cnt : res; }
/** * Returns the buffer that contains the wrapped data. * <p> * Retrieval and manipulation of this buffer should always be protected by the {@link #getWrapLock() wrap lock}. * * @return the buffer containing wrapped bytes */ public ByteBuffer getWrappedBuffer() { assert Thread.holdsLock(getWrapLock()); assert ! Thread.holdsLock(getUnwrapLock()); return allAreSet(stateUpdater.get(this), ENGINE_CLOSED)? Buffers.EMPTY_BYTE_BUFFER: sendBuffer.getResource(); }
public boolean isDataAvailable() { synchronized (getUnwrapLock()) { try { return readBuffer.getResource().hasRemaining() || (receiveBuffer.getResource().hasRemaining() && !isUnderflow()); } catch (IllegalStateException ignored) { return false; } } } }
final ByteBuffer src; try { src = pooledBuffer.getResource(); final int pos = src.position(); final int rem = src.remaining(); int res = target.write(src); if(res == 0) { } else { cnt = target.write(src); if (cnt == rem) { pooledBuffer.free(); } else { if (cnt == 0) {
final ByteBuffer src; try { src = buffer.getResource(); final int pos = src.position(); final int rem = src.remaining(); buffer.free(); } else { return cnt; cnt = 0L; return cnt + next.transferTo(position, count, target);