Refine search
public ByteBuffer acquire(int capacity, boolean direct) { ByteBuffer buffer = byteBufferPool.acquire(capacity, direct); BufferUtil.clearToFill(buffer); return buffer; }
@Override public void failed(Throwable x) { bufs.release(buf); } }
void releaseRequestBuffer() { if (_requestBuffer != null && !_requestBuffer.hasRemaining()) { if (LOG.isDebugEnabled()) LOG.debug("releaseRequestBuffer {}",this); ByteBuffer buffer=_requestBuffer; _requestBuffer=null; _bufferPool.release(buffer); } }
@Override protected Action process() throws Exception { // Only return if EOF has previously been read and thus // a write done with EOF=true if (_eof) { if (LOG.isDebugEnabled()) LOG.debug("EOF of {}",this); _in.close(); closed(); _channel.getByteBufferPool().release(_buffer); return Action.SUCCEEDED; } // Read from stream until buffer full or EOF BufferUtil.clearToFill(_buffer); while (_buffer.hasRemaining() && !_eof) _eof = (_in.read(_buffer)) < 0; // write what we have BufferUtil.flipToFlush(_buffer, 0); write(_buffer,_eof,this); return Action.SCHEDULED; }
@Override public void onFillable() if (LOG.isDebugEnabled()) LOG.debug("{} onFillable()",policy.getBehavior()); stats.countOnFillableEvents.incrementAndGet(); ByteBuffer buffer = bufferPool.acquire(getInputBufferSize(),true); bufferPool.release(buffer);
if (LOG.isDebugEnabled()) LOG.debug("EOF of {}",this); _channel.getByteBufferPool().release(_buffer); return Action.SUCCEEDED;
private Action batch() { if (aggregate == null) { aggregate = bufferPool.acquire(bufferSize, true); if (LOG.isDebugEnabled()) LOG.debug("{} acquired aggregate buffer {}", this, aggregate); } for (FrameEntry entry : entries) { entry.generateHeaderBytes(aggregate); ByteBuffer payload = entry.frame.getPayload(); if (BufferUtil.hasContent(payload)) BufferUtil.append(aggregate, payload); } if (LOG.isDebugEnabled()) LOG.debug("{} aggregated {} frames: {}", this, entries.size(), entries); // We just aggregated the entries, so we need to succeed their callbacks. succeeded(); return Action.SCHEDULED; }
@Override public void onFillable() { LOG.debug("{} onFillable()",policy.getBehavior()); stats.countOnFillableEvents.incrementAndGet(); ByteBuffer buffer = bufferPool.acquire(getInputBufferSize(),true); BufferUtil.clear(buffer); boolean readMore = false; try { isFilling = true; readMore = (read(buffer) != -1); } finally { bufferPool.release(buffer); } if (readMore && (suspendToken.get() == false)) { fillInterested(); } else { isFilling = false; } }
@Override public void onContent(final Response response, ByteBuffer content) { if (LOG.isDebugEnabled()) LOG.debug("onContent called with response: {} and content: {}. Sending response content to client.", response, content); final ByteBuffer contentCopy = httpClient.getByteBufferPool().acquire(content.remaining(), true); BufferUtil.flipPutFlip(content, contentCopy); ByteBufferDataInfo dataInfo = new ByteBufferDataInfo(contentCopy, false); clientStream.data(dataInfo, new Callback() { @Override public void failed(Throwable x) { LOG.debug("failed: ", x); releaseBuffer(); response.abort(x); } @Override public void succeeded() { releaseBuffer(); } private void releaseBuffer() { httpClient.getByteBufferPool().release(contentCopy); } }); }
bufferPool.acquire(bufferSize, true); channel = Files.newByteChannel(filePath, StandardOpenOption.READ); if (LOG.isDebugEnabled()) LOG.debug("Opened file {}", filePath); throw new NoSuchElementException(); if (LOG.isDebugEnabled()) LOG.debug("Read {} bytes from {}", read, filePath);
@Override public ByteBuffer acquire(int size, boolean direct) { ByteBuffer buffer = delegate.acquire(size, direct); boolean leaked = leakDetector.acquired(buffer); if (NOISY || !leaked) { leakedAcquires.incrementAndGet(); LOG.info(String.format("ByteBuffer acquire %s leaked.acquired=%s", leakDetector.id(buffer), leaked ? "normal" : "LEAK"), new Throwable("LeakStack.Acquire")); } return buffer; }
@Override public void release(ByteBuffer buffer) { if (buffer == null) return; boolean leaked = leakDetector.released(buffer); if (NOISY || !leaked) { leakedReleases.incrementAndGet(); LOG.info(String.format("ByteBuffer release %s leaked.released=%s", leakDetector.id(buffer), leaked ? "normal" : "LEAK"), new Throwable( "LeakStack.Release")); } delegate.release(buffer); }
public <C> void output(C context, Callback<C> callback, long channelId, WebSocketFrame frame) throws IOException { ByteBuffer muxPayload = bufferPool.acquire(frame.getPayloadLength() + DATA_FRAME_OVERHEAD,false); BufferUtil.flipToFill(muxPayload); // start building mux payload writeChannelId(muxPayload,channelId); byte b = (byte)(frame.isFin()?0x80:0x00); // fin b |= (byte)(frame.isRsv1()?0x40:0x00); // rsv1 b |= (byte)(frame.isRsv2()?0x20:0x00); // rsv2 b |= (byte)(frame.isRsv3()?0x10:0x00); // rsv3 b |= (byte)(frame.getOpCode() & 0x0F); // opcode muxPayload.put(b); BufferUtil.put(frame.getPayload(),muxPayload); // build muxed frame WebSocketFrame muxFrame = WebSocketFrame.binary(); BufferUtil.flipToFlush(muxPayload,0); muxFrame.setPayload(muxPayload); // NOTE: the physical connection will handle masking rules for this frame. // release original buffer (no longer needed) bufferPool.release(frame.getPayload()); // send muxed frame down to the physical connection. outgoing.output(context,callback,muxFrame); }
@Override public void completed(C context) { LOG.debug("completed() - frame: {}",frame); connection.getBufferPool().release(buffer); super.completed(context); if (frame.getOpCode() == OpCode.CLOSE) { CloseInfo close = new CloseInfo(origPayload,false); connection.onCloseHandshake(false,close); } connection.flush(); }
_channel.write(ByteBuffer.wrap(b, off, len), false); _written += len; return; _aggregate = _channel.getByteBufferPool().acquire(size, OUTPUT_BUFFER_DIRECT); int space = BufferUtil.space(_aggregate); if (len > space) if (BufferUtil.hasContent(_aggregate)) _channel.write(_aggregate, false); space = BufferUtil.space(_aggregate);
@Override public void onCompleteFailure(Throwable x) { super.onCompleteFailure(x); _channel.getByteBufferPool().release(_buffer); try { _in.close(); } catch (IOException e) { LOG.ignore(e); } }
boolean complete=_channel.getResponse().isAllContentWritten(_written); _aggregate = _channel.getByteBufferPool().acquire(getBufferSize(), _interceptor.isOptimizedForDirectBuffers()); BufferUtil.append(_aggregate, (byte)b); if (complete || BufferUtil.isFull(_aggregate)) _aggregate = _channel.getByteBufferPool().acquire(getBufferSize(), _interceptor.isOptimizedForDirectBuffers()); BufferUtil.append(_aggregate, (byte)b);
@Override public void write(int b) throws IOException { if (isClosed()) throw new EOFException("Closed"); if (_aggregate == null) _aggregate = _channel.getByteBufferPool().acquire(getBufferSize(), OUTPUT_BUFFER_DIRECT); BufferUtil.append(_aggregate, (byte)b); _written++; // Check if all written or full if (!closeIfAllContentWritten() && BufferUtil.isFull(_aggregate)) _channel.write(_aggregate, false); }