Examples of io.netty.buffer.ByteBuf

io.netty.buffer.ByteBuf
kipedia.org/wiki/Zero-based_numbering">zero-based indexing. It means the index of the first byte is always {@code 0} and the index of the last byte isalways {@link #capacity() capacity - 1}. For example, to iterate all bytes of a buffer, you can do the following, regardless of its internal implementation:
```
 {@link ByteBuf} buffer = ...;for (int i = 0; i < buffer.capacity(); i ++) { byte b = buffer.getByte(i); System.out.println((char) b); } 
```
Sequential Access Indexing
{@link ByteBuf} provides two pointer variables to support sequentialread and write operations - {@link #readerIndex() readerIndex} for a readoperation and {@link #writerIndex() writerIndex} for a write operationrespectively. The following diagram shows how a buffer is segmented into three areas by the two pointers:
```
 +-------------------+------------------+------------------+ | discardable bytes |  readable bytes  |  writable bytes  | |                   |     (CONTENT)    |                  | +-------------------+------------------+------------------+ |                   |                  |                  | 0      <=      readerIndex   <=   writerIndex    <=    capacity 
```
Readable bytes (the actual content)
This segment is where the actual data is stored. Any operation whose name starts with {@code read} or {@code skip} will get or skip the data at thecurrent {@link #readerIndex() readerIndex} and increase it by the number ofread bytes. If the argument of the read operation is also a {@link ByteBuf} and no destination index is specified, the specifiedbuffer's {@link #readerIndex() readerIndex} is increased together.
If there's not enough content left, {@link IndexOutOfBoundsException} israised. The default value of newly allocated, wrapped or copied buffer's {@link #readerIndex() readerIndex} is {@code 0}.
```
 // Iterates the readable bytes of a buffer. {@link ByteBuf} buffer = ...;while (buffer.readable()) { System.out.println(buffer.readByte()); } 
```
Writable bytes
This segment is a undefined space which needs to be filled. Any operation whose name ends with {@code write} will write the data at the current{@link #writerIndex() writerIndex} and increase it by the number of writtenbytes. If the argument of the write operation is also a {@link ByteBuf}, and no source index is specified, the specified buffer's {@link #readerIndex() readerIndex} is increased together.
If there's not enough writable bytes left, {@link IndexOutOfBoundsException}is raised. The default value of newly allocated buffer's {@link #writerIndex() writerIndex} is {@code 0}. The default value of wrapped or copied buffer's {@link #writerIndex() writerIndex} is the{@link #capacity() capacity} of the buffer.
```
 // Fills the writable bytes of a buffer with random integers. {@link ByteBuf} buffer = ...;while (buffer.writableBytes() >= 4) { buffer.writeInt(random.nextInt()); } 
```
Discardable bytes
This segment contains the bytes which were read already by a read operation. Initially, the size of this segment is {@code 0}, but its size increases up to the {@link #writerIndex() writerIndex} as read operations are executed.The read bytes can be discarded by calling {@link #discardReadBytes()} toreclaim unused area as depicted by the following diagram:
```
 BEFORE discardReadBytes() +-------------------+------------------+------------------+ | discardable bytes |  readable bytes  |  writable bytes  | +-------------------+------------------+------------------+ |                   |                  |                  | 0      <=      readerIndex   <=   writerIndex    <=    capacity AFTER discardReadBytes() +------------------+--------------------------------------+ |  readable bytes  |    writable bytes (got more space)   | +------------------+--------------------------------------+ |                  |                                      | readerIndex (0) <= writerIndex (decreased)        <=        capacity 
```
Please note that there is no guarantee about the content of writable bytes after calling {@link #discardReadBytes()}. The writable bytes will not be moved in most cases and could even be filled with completely different data depending on the underlying buffer implementation.
Clearing the buffer indexes
You can set both {@link #readerIndex() readerIndex} and{@link #writerIndex() writerIndex} to {@code 0} by calling {@link #clear()}. It does not clear the buffer content (e.g. filling with {@code 0}) but just clears the two pointers. Please also note that the semantic of this operation is different from {@link ByteBuffer#clear()}.
```
 BEFORE clear() +-------------------+------------------+------------------+ | discardable bytes |  readable bytes  |  writable bytes  | +-------------------+------------------+------------------+ |                   |                  |                  | 0      <=      readerIndex   <=   writerIndex    <=    capacity AFTER clear() +---------------------------------------------------------+ |             writable bytes (got more space)             | +---------------------------------------------------------+ |                                                         | 0 = readerIndex = writerIndex            <=            capacity 
```
Search operations
Various {@link #indexOf(int,int,byte)} methods help you locate an index ofa value which meets a certain criteria. Complicated dynamic sequential search can be done with {@link ByteBufIndexFinder} as well as simplestatic single byte search.
If you are decoding variable length data such as NUL-terminated string, you will find {@link #bytesBefore(byte)} also useful.
Mark and reset
There are two marker indexes in every buffer. One is for storing {@link #readerIndex() readerIndex} and the other is for storing{@link #writerIndex() writerIndex}. You can always reposition one of the two indexes by calling a reset method. It works in a similar fashion to the mark and reset methods in {@link InputStream} except that there's no{@code readlimit}.
Derived buffers
You can create a view of an existing buffer by calling either {@link #duplicate()}, {@link #slice()} or {@link #slice(int,int)}. A derived buffer will have an independent {@link #readerIndex() readerIndex}, {@link #writerIndex() writerIndex} and marker indexes, while it sharesother internal data representation, just like a NIO buffer does.
In case a completely fresh copy of an existing buffer is required, please call {@link #copy()} method instead.
Conversion to existing JDK types

Byte array
If a {@link ByteBuf} is backed by a byte array (i.e. {@code byte[]}), you can access it directly via the {@link #array()} method. To determineif a buffer is backed by a byte array, {@link #hasArray()} should be used.
NIO Buffers
If a {@link ByteBuf} can be converted into an NIO {@link ByteBuffer} which shares itscontent (i.e. view buffer), you can get it via the {@link #nioBuffer()} method. To determineif a buffer can be converted into an NIO buffer, use {@link #nioBuffer()}.
Strings
Various {@link #toString(Charset)} methods convert a {@link ByteBuf}into a {@link String}. Please note that {@link #toString()} is not aconversion method.
I/O Streams
Please refer to {@link ByteBufInputStream} and{@link ByteBufOutputStream}.

        this.remoteSocketAddress = remoteSocketAddress;
    }


    @Override
    public ByteBuf intercept(ChannelHandlerContext ctx, ByteBuf channelBuffer, Logger logger) throws Exception {
        ByteBuf channelBufferCopy = Unpooled.copiedBuffer(channelBuffer);
        logger.debug("INTERCEPTING - REQUEST: " + channelBuffer.toString(Charsets.UTF_8));
        try {
            List<ByteBuf> allRequestRawChunks = new ArrayList<ByteBuf>();
            List<Object> requestHttpFormattedChunks = new ArrayList<Object>();
            httpRequestDecoder.callDecode(ctx, channelBufferCopy, requestHttpFormattedChunks);


            for (Object httpChunk : requestHttpFormattedChunks) {
                if (httpChunk instanceof HttpRequest) {
                    HttpRequest httpRequest = (HttpRequest) httpChunk;
                    httpRequest.headers().remove(HttpHeaders.Names.ACCEPT_ENCODING);
                    if (remoteSocketAddress != null) {
                        httpRequest.headers().set(HttpHeaders.Names.HOST, remoteSocketAddress.getHostName() + ":" + remoteSocketAddress.getPort());
                    }
                    httpRequest.headers().set(HttpHeaders.Names.CONNECTION, HttpHeaders.Values.CLOSE);
                }
                logger.debug("HTTP-FORMATTED -REQUEST- " + httpChunk.getClass().getSimpleName() + " -- " + httpChunk);
                if (!(httpChunk instanceof LastHttpContent)) {
                    List<Object> requestRawChunks = new ArrayList<Object>();
                    httpRequestEncoder.encode(ctx, httpChunk, requestRawChunks);
                    for (Object rawChunk : requestRawChunks) {
                        if (rawChunk instanceof ByteBuf) {
                            allRequestRawChunks.add((ByteBuf) rawChunk);
                        }
                    }
                }
            }


            return Unpooled.copiedBuffer(allRequestRawChunks.toArray(new ByteBuf[allRequestRawChunks.size()]));
        } finally {
            channelBufferCopy.release();
        }
    }

View Full Code Here

    @Override
    public ByteBuf intercept(ChannelHandlerContext ctx, ByteBuf channelBuffer, Logger logger) throws Exception {
        if (true) {
            return channelBuffer;
        }
        ByteBuf channelBufferCopy = Unpooled.copiedBuffer(channelBuffer);
        logger.debug("INTERCEPTING - RESPONSE: " + channelBuffer.toString(Charsets.UTF_8));
        try {
            List<ByteBuf> allResponseRawChunks = new ArrayList<ByteBuf>();
            List<Object> responseHttpFormattedChunks = new ArrayList<Object>();
            httpResponseDecoder.callDecode(ctx, channelBufferCopy, responseHttpFormattedChunks);


            for (Object httpChunk : responseHttpFormattedChunks) {
                if (httpChunk instanceof HttpResponse) {
                    HttpResponse httpResponse = (HttpResponse) httpChunk;
                    httpResponse.headers().remove(HttpHeaders.Names.ACCEPT_ENCODING);
                    httpResponse.headers().set(HttpHeaders.Names.CONNECTION, HttpHeaders.Values.CLOSE);
                }
                logger.debug("HTTP-FORMATTED -RESPONSE- " + httpChunk.getClass().getSimpleName() + " -- " + httpChunk);
                if (!(httpChunk instanceof LastHttpContent)) {
                    List<Object> responseRawChunks = new ArrayList<Object>();
//                    if(httpChunk instanceof DefaultHttpContent) {
//                        httpChunk = ((DefaultHttpContent)httpChunk).content();
//                    }
                    httpResponseEncoder.encode(ctx, httpChunk, responseRawChunks);
                    for (Object rawChunk : responseRawChunks) {
                        if (rawChunk instanceof ByteBuf) {
                            allResponseRawChunks.add((ByteBuf) rawChunk);
                        }
                    }
                }
            }


            return Unpooled.copiedBuffer(allResponseRawChunks.toArray(new ByteBuf[allResponseRawChunks.size()]));
        } finally {
            channelBufferCopy.release();
        }
    }

View Full Code Here

    }


    @Override
    public void channelRead(final ChannelHandlerContext ctx, final Object msg) throws Exception {
        if (msg instanceof ByteBuf) {
            final ByteBuf chunk = (ByteBuf) msg;
            if (flushedBuffer) {
                bufferedMode = false;
            }
            if (bufferedMode) {


                flushContent = false;


                if (contentLength != null) {
                    contentSoFar += chunk.readableBytes();
                } else {
                    // find content length
                    BasicHttpDecoder basicHttpDecoder = new BasicHttpDecoder(Unpooled.copiedBuffer(chunk));
                    contentLength = basicHttpDecoder.getContentLength();
                    contentSoFar = (chunk.readableBytes() - basicHttpDecoder.getContentStart());
                }


                if (logger.isTraceEnabled()) {
                    logger.trace("CHUNK:                     ---\n-" + System.getProperty("line.separator") + Unpooled.copiedBuffer(chunk).toString(Charsets.UTF_8) + "\n-" + System.getProperty("line.separator"));
                    logger.trace("CONTENT-SO-FAR-PRE-CHUNK:  --- " + (contentSoFar - Unpooled.copiedBuffer(chunk).toString(Charsets.UTF_8).length()));
                    logger.trace("CHUNK-SIZE:                --- " + chunk.readableBytes());
                    logger.trace("CONTENT-SO-FAR-PRE-CHUNK:  --- " + contentSoFar);
                    if (contentLength != null) {
                        logger.trace("CONTENT-REMAINING:         --- " + (contentLength - contentSoFar));
                        logger.trace("CONTENT-LENGTH:            --- " + contentLength);
                    }
                }


                if (contentLength != null) {
                    logger.trace("Flushing buffer as all content received");
                    flushContent = (contentSoFar >= contentLength) || (chunk.readableBytes() == 0);
                }
                try {
                    channelBuffer.writeBytes(chunk);
                    ctx.channel().read();
                } catch (IndexOutOfBoundsException iobe) {
                    logger.trace("Flushing buffer upstream and switching to chunked mode as downstream response too large");
                    bufferedMode = false;
                    // write and flush buffer upstream
                    if (outboundChannel.isActive() && channelBuffer.isReadable()) {
                        logger.debug("CHANNEL READ EX: " + chunk.toString(Charsets.UTF_8));
                        outboundChannel.writeAndFlush(channelBuffer).addListener(new ChannelFutureListener() {
                            @Override
                            public void operationComplete(ChannelFuture future) throws Exception {
                                if (future.isSuccess()) {
                                    // write and flush this chunk upstream in case this single chunk is too large for buffer
                                    channelRead(ctx, chunk);
                                } else {
                                    logger.warn("Failed to write to: " + remoteSocketAddress, future.cause());
                                    future.channel().close();
                                }
                            }
                        });
                    }
                }
            } else {
                bufferedMode = false;
                if (outboundChannel.isActive()) {
                    logger.debug("CHANNEL READ NOT-BUFFERING: " + chunk.toString(Charsets.UTF_8));
                    outboundChannel.writeAndFlush(chunk).addListener(new ChannelFutureListener() {
                        @Override
                        public void operationComplete(ChannelFuture future) throws Exception {
                            if (future.isSuccess()) {
                                // was able to flush out data, start to read the next chunk

View Full Code Here

    @Override
    protected void channelRead0(ChannelHandlerContext ctx, Object msg) {
        if (msg instanceof FullHttpMessage && ((HttpObject) msg).getDecoderResult().isSuccess()) {
            HttpRequest request = (HttpRequest) msg;


            ByteBuf requestContent = Unpooled.copiedBuffer(((HttpContent) msg).content());


            DefaultFullHttpRequest mockServerHttpRequest = new DefaultFullHttpRequest(request.getProtocolVersion(), request.getMethod(), request.getUri(), requestContent);
            mockServerHttpRequest.headers().add(request.headers());


            LastHttpContent trailer = (LastHttpContent) msg;

View Full Code Here

            return new DefaultFullHttpResponse(HttpVersion.HTTP_1_1, HttpResponseStatus.NOT_FOUND);
        }
    }


    private ByteBuf getBody(HttpResponse httpResponse) {
        ByteBuf content = Unpooled.buffer(0);
        if (httpResponse.getBodyAsString() != null) {
            if (httpResponse.getBody() instanceof BinaryBody) {
                content = Unpooled.copiedBuffer(Base64Converter.base64StringToBytes(httpResponse.getBodyAsString()));
            } else {
                content = Unpooled.copiedBuffer(httpResponse.getBodyAsString().getBytes());

View Full Code Here

    }


    @Override
    public void channelRead(final ChannelHandlerContext ctx, final Object msg) throws Exception {
        if (msg instanceof ByteBuf) {
            final ByteBuf chunk = (ByteBuf) msg;
            if (flushedBuffer) {
                bufferedMode = false;
            }
            if (bufferedMode) {


                flushContent = false;


                if (contentLength != null) {
                    contentSoFar += chunk.readableBytes();
                } else {
                    // find content length
                    BasicHttpDecoder basicHttpDecoder = new BasicHttpDecoder(Unpooled.copiedBuffer(chunk));
                    contentLength = basicHttpDecoder.getContentLength();
                    contentSoFar = (chunk.readableBytes() - basicHttpDecoder.getContentStart());
                }


                if (logger.isTraceEnabled()) {
                    logger.trace("CHUNK:                     ---\n-" + System.getProperty("line.separator") + Unpooled.copiedBuffer(chunk).toString(Charsets.UTF_8) + "\n-" + System.getProperty("line.separator"));
                    logger.trace("CONTENT-SO-FAR-PRE-CHUNK:  --- " + (contentSoFar - Unpooled.copiedBuffer(chunk).toString(Charsets.UTF_8).length()));
                    logger.trace("CHUNK-SIZE:                --- " + chunk.readableBytes());
                    logger.trace("CONTENT-SO-FAR-PRE-CHUNK:  --- " + contentSoFar);
                    if (contentLength != null) {
                        logger.trace("CONTENT-REMAINING:         --- " + (contentLength - contentSoFar));
                        logger.trace("CONTENT-LENGTH:            --- " + contentLength);
                    }
                }


                if (contentLength != null) {
                    logger.trace("Flushing buffer as all content received");
                    flushContent = (contentSoFar >= contentLength) || (chunk.readableBytes() == 0);
                }
                try {
                    channelBuffer.writeBytes(chunk);
                    ctx.channel().read();
                } catch (IndexOutOfBoundsException iobe) {
                    logger.trace("Flushing buffer and switching to chunked mode as buffer full");
                    flushContent = true;
                }
                if (flushContent) {
                    flushedBuffer = true;
                    if (relayChannel.isActive() && channelBuffer.isReadable()) {
                        logger.debug("CHANNEL READ EX: " + chunk.toString(Charsets.UTF_8));
                        relayChannel.writeAndFlush(channelBuffer).addListener(new ChannelFutureListener() {
                            @Override
                            public void operationComplete(ChannelFuture future) throws Exception {
                                if (future.isSuccess()) {
                                    channelBuffer.clear();
                                    // write and flush this chunk upstream in case this single chunk is too large for buffer
                                    channelRead(ctx, chunk);
                                } else {
                                    logger.warn("Failed to send flush channel buffer [" + channelBuffer + "]", future.cause());
                                    future.channel().close();
                                }
                            }
                        });
                    }
                }
            } else {
                bufferedMode = false;
                if (relayChannel.isActive()) {
                    logger.debug("CHANNEL READ NOT-BUFFERING: " + chunk.toString(Charsets.UTF_8));
                    relayChannel.writeAndFlush(chunk).addListener(new ChannelFutureListener() {
                        @Override
                        public void operationComplete(ChannelFuture future) throws Exception {
                            if (future.isSuccess()) {
                                // was able to flush out data, start to read the next chunk

View Full Code Here

        roundTrip( "80FFFF" );
    }


    protected void roundTrip(String hex) {
        BigInteger i = new BigInteger( hex, 16 );
        ByteBuf buf = BigIntegerUtils.toBuf( i );
        assertEquals( hex.length() / 2, buf.readableBytes() );
        BigInteger i2 = BigIntegerUtils.fromBuf( buf );
        assertEquals( i, i2 );
    }

View Full Code Here

 */
public class OpenSSLKDFTest {


    @Test
    public void testGeneration() {
        ByteBuf password = Unpooled.buffer();
        password.writeBytes( "tacos".getBytes() );
        OpenSSLKDF kdf = new OpenSSLKDF(password, 64, 8);


        ByteBuf key = kdf.getKey();


        assertEquals(key.getByte(0) & 0xff, 0xda);
        assertEquals(key.getByte(1) & 0xff, 0xce);
        assertEquals(key.getByte(2) & 0xff, 0xdf);
        assertEquals(key.getByte(3) & 0xff, 0x41);
        assertEquals(key.getByte(4) & 0xff, 0x21);
        assertEquals(key.getByte(5) & 0xff, 0x04);
        assertEquals(key.getByte(6) & 0xff, 0x44);
        assertEquals(key.getByte(7) & 0xff, 0xfe);


        ByteBuf iv = kdf.getIv();


        assertEquals(iv.getByte(0) & 0xff, 0x85);
        assertEquals(iv.getByte(1) & 0xff, 0x47);
        assertEquals(iv.getByte(2) & 0xff, 0xf5);
        assertEquals(iv.getByte(3) & 0xff, 0xb1);
        assertEquals(iv.getByte(4) & 0xff, 0xcf);
        assertEquals(iv.getByte(5) & 0xff, 0x08);
        assertEquals(iv.getByte(6) & 0xff, 0x5a);
        assertEquals(iv.getByte(7) & 0xff, 0x6c);




    }

View Full Code Here

    public void write(ByteBuf buf) throws IOException {
        this.channelFuture.channel().writeAndFlush(buf.retain());
    }


    public void writeUtf8String(String str) throws IOException {
        ByteBuf buf = this.channelFuture.channel().alloc().buffer();
        buf.writeBytes(str.getBytes("utf8"));
        write(buf);
    }

View Full Code Here

        buf.writeBytes(str.getBytes("utf8"));
        write(buf);
    }


    public void writeAsciiString(String str) throws IOException {
        ByteBuf buf = this.channelFuture.channel().alloc().buffer();
        buf.writeBytes(str.getBytes("us-ascii"));
        write(buf);
    }

View Full Code Here

0 1 2 3 4 5 6 7 8 9

TOP

Related Classes of io.netty.buffer.ByteBuf

codechicken.lib.packet.PacketCustom

cofh.core.network.PacketHandler

com.addthis.muxy.MuxStreamDirectory

com.adobe.acs.livereload.impl.WebSocketServerHandler

com.alibaba.rocketmq.remoting.netty.NettyDecoder

com.corundumstudio.socketio.parser.Decoder

com.corundumstudio.socketio.protocol.PacketDecoder

com.corundumstudio.socketio.protocol.PacketEncoder

com.couchbase.client.core.endpoint.config.ConfigHandler

com.couchbase.client.core.endpoint.kv.KeyValueAuthHandler

All source code are property of their respective owners. Java is a trademark of Sun Microsystems, Inc and owned by ORACLE Inc. Contact coftware#gmail.com.

Examples of io.netty.buffer.ByteBuf

Sequential Access Indexing

Readable bytes (the actual content)

Writable bytes

Discardable bytes

Clearing the buffer indexes

Search operations

Mark and reset

Derived buffers

Conversion to existing JDK types

Byte array

NIO Buffers

Strings

I/O Streams

Related Classes of io.netty.buffer.ByteBuf