@Override public void write(int b) throws IOException { final byte[] buffer = new byte[1]; buffer[0] = (byte) b; delegate.feed(Buffers.wrap(MemoryManager.DEFAULT_MEMORY_MANAGER, buffer), false); }
public GrizzlyResponse(final HttpResponsePacket httpResponsePacket, final HttpResponseStatus status, final HttpResponseHeaders headers, final List<HttpResponseBodyPart> bodyParts) { super(status, headers, bodyParts); this.httpResponsePacket = httpResponsePacket; if (isNonEmpty(bodyParts)) { if (bodyParts.size() == 1) { responseBody = ((GrizzlyResponseBodyPart) bodyParts.get(0)).getBodyBuffer(); } else { final Buffer firstBuffer = ((GrizzlyResponseBodyPart) bodyParts.get(0)).getBodyBuffer(); final MemoryManager mm = httpResponsePacket.getRequest().getConnection().getMemoryManager(); Buffer constructedBodyBuffer = firstBuffer; for (int i = 1, len = bodyParts.size(); i < len; i++) { constructedBodyBuffer = Buffers.appendBuffers(mm, constructedBodyBuffer, ((GrizzlyResponseBodyPart) bodyParts.get(i)).getBodyBuffer()); } responseBody = constructedBodyBuffer; } } else { responseBody = Buffers.EMPTY_BUFFER; } }
final long timeoutMillis) throws IOException { final Connection connection = ctx.getConnection(); final SSLEngine sslEngine = sslCtx.getSslEngine(); final long oldReadTimeout = connection.getReadTimeout(TimeUnit.MILLISECONDS); connection.setReadTimeout(timeoutMillis, TimeUnit.MILLISECONDS); final ReadResult rr = ctx.read(); final Buffer newBuf = (Buffer) rr.getMessage(); inputBuffer = Buffers.appendBuffers(ctx.getMemoryManager(), inputBuffer, newBuf); inputBuffer = makeInputRemainder(sslCtx, ctx, tmpAppBuffer.dispose(); connection.setReadTimeout(oldReadTimeout, TimeUnit.MILLISECONDS);
Buffer cloneContent(final MemoryManager memoryManager) { final Buffer buffer; final int length = remaining(); if (!hasClonedArray) { buffer = memoryManager.allocate(length); buffer.put(heap, offset + pos, length); buffer.flip(); } else { buffer = Buffers.wrap(memoryManager, heap, offset + pos, length); } buffer.allowBufferDispose(true); dispose(); return buffer; }
@SuppressWarnings("unchecked") protected void sendRaw(byte[] rawData) { final Connection connection = protocolHandler.getConnection(); final MemoryManager mm = connection.getTransport().getMemoryManager(); final Buffer buffer = Buffers.wrap(mm, rawData); buffer.allowBufferDispose(false); connection.write(buffer); }
@Override public HttpContent append(final HttpContent element) { if (isLast) { throw new IllegalStateException("Can not append to a last chunk"); } if (isBroken(element)) { return element; } final Buffer content2 = element.getContent(); if (content2 != null && content2.hasRemaining()) { content = Buffers.appendBuffers(null, content, content2); } if (element.isLast()) { element.setContent(content); return element; } return this; }
final MemoryManager mm = ctx.getMemoryManager(); final Buffer gBuffer = Buffers.wrap(mm, data); final HttpContent content = requestPacket.httpContentBuilder() .content(gBuffer) requestPacket.setContentLengthLong(data.length); ctx.write(content, ((!requestPacket.isCommitted()) ? ctx.getTransportContext().getCompletionHandler() : null));
/** * {@inheritDoc} */ @Override protected TransformationResult<Buffer, Buffer> transformImpl( AttributeStorage storage, Buffer input) throws TransformationException { final MemoryManager memoryManager = obtainMemoryManager(storage); final GZipOutputState state = (GZipOutputState) obtainStateObject(storage); if (!state.isInitialized) { state.initialize(); } Buffer encodedBuffer = null; if (input != null && input.hasRemaining()) { encodedBuffer = encodeBuffer(input, state, memoryManager); } if (encodedBuffer == null) { return TransformationResult.createIncompletedResult(null); } // Put GZIP header if needed if (!state.isHeaderWritten) { state.isHeaderWritten = true; encodedBuffer = Buffers.appendBuffers(memoryManager, getHeader(), encodedBuffer); } return TransformationResult.createCompletedResult(encodedBuffer, null); }
public void append(final BufferChunk bc) { final int oldPos = buffer.position(); final int oldLim = buffer.limit(); final int srcLen = bc.getLength() ; Buffers.setPositionLimit(buffer, end, end + srcLen); buffer.put(bc.getBuffer(), bc.getStart(), srcLen); Buffers.setPositionLimit(buffer, oldPos, oldLim); end += srcLen; }
/** * Clones the source {@link Buffer}. * The method returns a new {@link Buffer} instance, which has the same content. * Please note, source and result {@link Buffer}s have the same content, * but it is *not* shared, so the following content changes in one of the * {@link Buffer}s won't be visible in another one. * * @param srcBuffer the source {@link Buffer}. * @return the cloned {@link Buffer}. */ public static Buffer cloneBuffer(final Buffer srcBuffer) { return cloneBuffer(srcBuffer, srcBuffer.position(), srcBuffer.limit()); }
@Test public void testBuffers() { Buffer sampleBuffer = Buffers.wrap(mm, new byte[]{-1, 0, 1, 1, 2, 3, 4}); Buffer b1 = mm.allocate(3); Buffer b2 = mm.allocate(4); CompositeBuffer compositeBuffer = createCompositeBuffer(b1, b2); compositeBuffer.put(sampleBuffer); compositeBuffer.flip(); sampleBuffer.flip(); while (sampleBuffer.hasRemaining()) { assertEquals(sampleBuffer.get(), compositeBuffer.get()); } }
public boolean append(final Buffer buffer) { currentHeaderSize += buffer.remaining(); if (currentHeaderSize <= maxHeaderSize) { inBuffer = Buffers.appendBuffers(memoryManager, inBuffer, buffer, true); return true; } return false; }
@Test public void testEmptyBufferPrepend() { Buffer buffer1 = Buffers.wrap(mm, "1234"); buffer1.position(3); Buffer buffer2 = mm.allocate(0); CompositeBuffer compositeBuffer = createCompositeBuffer(buffer1); assertEquals('4', (char) compositeBuffer.get(0)); Buffer resultBuffer = Buffers.appendBuffers(mm, buffer2, compositeBuffer); assertEquals(resultBuffer.toStringContent(), "4"); }
@Override public NextAction handleConnect(FilterChainContext ctx) throws IOException { ctx.write(Buffers.wrap(MemoryManager.DEFAULT_MEMORY_MANAGER, ".")); return ctx.getStopAction(); }
private void flushBufferedData() { if (buffer.size() == 0) { // buffer is empty return; } Buffer message = Buffers.wrap(grizzlyConnection.getMemoryManager(), buffer.toByteArray()); grizzlyConnection.write(message); buffer.reset(); } }
@Override public void replayPayload(byte[] payloadByteArray) { if (payloadByteArray == null) { return; } coyoteRequest.replayPayload(Buffers.wrap( coyoteRequest.getContext().getMemoryManager(), payloadByteArray)); }
static FilterStateElement create( final boolean isIncomplete, final Object remainder) { if (remainder instanceof Buffer) { return create(isIncomplete, (Buffer) remainder, Buffers.getBufferAppender(true)); } else { return create(isIncomplete, (Appendable) remainder); } }
/** * Generates a hex dump of the provided {@link Buffer}. * @param appendable the {@link Appendable} to write the hex dump to. * @param buffer the {@link Buffer} to dump. * * @since 2.3.23 */ @SuppressWarnings("unused") public static void dumpBuffer(final Appendable appendable, final Buffer buffer) { final Formatter formatter = new Formatter(appendable); dumpBuffer0(formatter, appendable, buffer); }
/** * {@inheritDoc} */ @Override public void dumpHex(java.lang.Appendable appendable) { Buffers.dumpBuffer(appendable, this); }