Example usage for io.netty.buffer ByteBuf refCnt

Introduction

In this page you can find the example usage for io.netty.buffer ByteBuf refCnt.

Prototype

int refCnt();

Source Link

Document

Returns the reference count of this object.

Usage

From source file:com.couchbase.client.core.endpoint.kv.KeyValueHandlerTest.java

License:Apache License

@Test
public void shouldNotReleasePrependRequestContentOnRetry() throws Exception {
    ByteBuf content = Unpooled.copiedBuffer("content", CharsetUtil.UTF_8);
    FullBinaryMemcacheResponse response = new DefaultFullBinaryMemcacheResponse(KEY, Unpooled.EMPTY_BUFFER,
            content);/*from  w  ww . ja va  2 s.c  o  m*/
    response.setStatus(KeyValueStatus.ERR_NOT_MY_VBUCKET.code());

    PrependRequest requestMock = mock(PrependRequest.class);
    ByteBuf requestContent = Unpooled.copiedBuffer("content", CharsetUtil.UTF_8);
    when(requestMock.bucket()).thenReturn("bucket");
    when(requestMock.observable()).thenReturn(AsyncSubject.<CouchbaseResponse>create());
    when(requestMock.content()).thenReturn(requestContent);
    requestQueue.add(requestMock);

    assertEquals(1, content.refCnt());
    assertEquals(1, requestContent.refCnt());
    channel.writeInbound(response);
    assertEquals(1, content.refCnt());
    assertEquals(1, requestContent.refCnt());
}

---

From source file:com.couchbase.client.core.endpoint.kv.KeyValueHandlerTest.java

License:Apache License

@Test(expected = CouchbaseException.class)
public void shouldFailWhenOpaqueDoesNotMatch() throws Exception {
    ByteBuf content = Unpooled.copiedBuffer("content", CharsetUtil.UTF_8);
    FullBinaryMemcacheResponse response = new DefaultFullBinaryMemcacheResponse(KEY, Unpooled.EMPTY_BUFFER,
            content);/*  ww  w  .ja v  a 2  s  . co m*/
    response.setStatus(BinaryMemcacheResponseStatus.SUCCESS);
    response.setOpaque(1);

    PrependRequest requestMock = mock(PrependRequest.class);
    ByteBuf requestContent = Unpooled.copiedBuffer("content", CharsetUtil.UTF_8);
    when(requestMock.bucket()).thenReturn("bucket");
    AsyncSubject<CouchbaseResponse> responseSubject = AsyncSubject.<CouchbaseResponse>create();
    when(requestMock.observable()).thenReturn(responseSubject);
    when(requestMock.content()).thenReturn(requestContent);
    when(requestMock.opaque()).thenReturn(3);
    requestQueue.add(requestMock);

    channel.writeInbound(response);
    assertEquals(0, content.refCnt());
    responseSubject.toBlocking().single();
}

---

From source file:com.couchbase.client.core.ResponseHandlerTest.java

License:Apache License

@Test
public void shouldSendProposedConfigToProvider() throws Exception {
    ClusterFacade clusterMock = mock(ClusterFacade.class);
    ConfigurationProvider providerMock = mock(ConfigurationProvider.class);
    ResponseHandler handler = new ResponseHandler(ENVIRONMENT, clusterMock, providerMock);
    ByteBuf config = Unpooled.copiedBuffer("{\"json\": true}", CharsetUtil.UTF_8);

    ResponseEvent retryEvent = new ResponseEvent();
    retryEvent.setMessage(new InsertResponse(ResponseStatus.RETRY, KeyValueStatus.ERR_TEMP_FAIL.code(), 0,
            "bucket", config, null, mock(InsertRequest.class)));
    retryEvent.setObservable(mock(Subject.class));
    handler.onEvent(retryEvent, 1, true);

    verify(providerMock, times(1)).proposeBucketConfig("bucket", "{\"json\": true}");
    assertEquals(0, config.refCnt());
    assertNull(retryEvent.getMessage());
    assertNull(retryEvent.getObservable());
}

---

From source file:com.couchbase.client.core.ResponseHandlerTest.java

License:Apache License

@Test
public void shouldIgnoreInvalidConfig() throws Exception {
    ClusterFacade clusterMock = mock(ClusterFacade.class);
    ConfigurationProvider providerMock = mock(ConfigurationProvider.class);
    ResponseHandler handler = new ResponseHandler(ENVIRONMENT, clusterMock, providerMock);
    ByteBuf config = Unpooled.copiedBuffer("Not my Vbucket", CharsetUtil.UTF_8);

    ResponseEvent retryEvent = new ResponseEvent();
    retryEvent.setMessage(new InsertResponse(ResponseStatus.RETRY, KeyValueStatus.ERR_TEMP_FAIL.code(), 0,
            "bucket", config, null, mock(InsertRequest.class)));
    retryEvent.setObservable(mock(Subject.class));
    handler.onEvent(retryEvent, 1, true);

    verify(providerMock, never()).proposeBucketConfig("bucket", "Not my Vbucket");
    assertEquals(0, config.refCnt());
    assertNull(retryEvent.getMessage());
    assertNull(retryEvent.getObservable());
}

---

From source file:com.couchbase.client.core.utils.BuffersTest.java

License:Apache License

@Test
public void shouldReleaseIfUnsubscribed() {
    ReplaySubject<ByteBuf> source = ReplaySubject.create();
    Observable<ByteBuf> wrapped = Buffers.wrapColdWithAutoRelease(source);

    for (int i = 0; i < 5; i++) {
        source.onNext(Unpooled.buffer());
    }/*from w w  w  . j ava 2s . com*/
    source.onCompleted();

    source.toBlocking().forEach(new Action1<ByteBuf>() {
        @Override
        public void call(ByteBuf byteBuf) {
            assertEquals(1, byteBuf.refCnt());
        }
    });

    wrapped.take(2).toBlocking().forEach(new Action1<ByteBuf>() {
        @Override
        public void call(ByteBuf byteBuf) {
            byteBuf.release();
        }
    });

    source.toBlocking().forEach(new Action1<ByteBuf>() {
        @Override
        public void call(ByteBuf byteBuf) {
            assertEquals(0, byteBuf.refCnt());
        }
    });

}

---

From source file:com.couchbase.client.core.utils.UnicastAutoReleaseSubjectTest.java

License:Apache License

@Test
public void testByteBufReleaseWithNoTimeout() throws Exception {
    UnicastAutoReleaseSubject<ByteBuf> subject = UnicastAutoReleaseSubject.createWithoutNoSubscriptionTimeout();
    ByteBuf buffer = Unpooled.buffer();
    Assert.assertEquals("Created byte buffer not retained.", 1, buffer.refCnt());
    subject.onNext(buffer);//w w w .  j  a  v a2  s.com
    subject.onCompleted();
    final AtomicInteger byteBufRefCnt = new AtomicInteger(-1);

    ByteBuf last = subject.doOnNext(new Action1<ByteBuf>() {
        @Override
        public void call(ByteBuf byteBuf) {
            byteBufRefCnt.set(byteBuf.refCnt());
            byteBuf.release();// Simulate consumption as ByteBuf refcount is 1 when created.
        }
    }).toBlocking().last();

    Assert.assertEquals("Unexpected ByteBuf ref count when received.", 1, byteBufRefCnt.get());
    Assert.assertSame("Unexpected byte buffer received.", buffer, last);
    Assert.assertEquals("Byte buffer not released.", 0, last.refCnt());
}

---

From source file:com.couchbase.client.core.utils.UnicastAutoReleaseSubjectTest.java

License:Apache License

@Test
public void testByteBufReleaseWithTimeout() throws Exception {
    TestScheduler testScheduler = Schedulers.test();
    UnicastAutoReleaseSubject<ByteBuf> subject = UnicastAutoReleaseSubject.create(100, TimeUnit.MILLISECONDS,
            testScheduler);//from www .ja  v  a2s.  c  o m
    ByteBuf buffer = Unpooled.buffer();

    subject.onNext(buffer);
    Assert.assertEquals("Byte buffer not retained on buffering by subject.", 1, buffer.refCnt());

    subject.onCompleted();

    testScheduler.advanceTimeBy(100, TimeUnit.MILLISECONDS);
    Assert.assertEquals("Byte buffer not fully released", 0, buffer.refCnt());
}

---

From source file:com.github.milenkovicm.kafka.AbstractTest.java

License:Apache License

@After
public void after() {
    for (;;) {//from w w  w .  j  av a2 s  .  c o  m
        final ByteBuf buf = freeLaterQueue.poll();
        if (buf == null) {
            break;
        }
        if (buf.refCnt() > 0) {
            buf.release(buf.refCnt());
        }
    }
}

---

From source file:com.github.sadikovi.netflowlib.NetFlowReader.java

License:Apache License

/** Prepare header using provided input stream */
private NetFlowHeader prepareHeader() throws IOException {
    NetFlowHeader internalHeader;/*from  ww w  .j ava2  s  . c o m*/
    int numBytesRead = 0;
    int lenRead = 0;
    ByteBuf buf;
    byte[] headerArray;

    // Read header depending on stream version (different from flow version)
    if (streamVersion == 1) {
        // Version 1 has static header
        // TODO: verify header size for stream version 1
        lenRead = NetFlowHeader.S1_HEADER_SIZE - METADATA_LENGTH;
        internalHeader = new NetFlowHeader(streamVersion, byteOrder);
    } else {
        // Version 3 with dynamic header size
        headerArray = new byte[HEADER_OFFSET_LENGTH];
        numBytesRead = in.read(headerArray, 0, HEADER_OFFSET_LENGTH);
        if (numBytesRead != HEADER_OFFSET_LENGTH) {
            throw new UnsupportedOperationException("Short read while loading header offset");
        }

        buf = Unpooled.wrappedBuffer(headerArray).order(byteOrder);
        int headerSize = (int) buf.getUnsignedInt(0);
        if (headerSize <= 0) {
            throw new UnsupportedOperationException("Failed to load header of size " + headerSize);
        }

        // Actual header length, determine how many bytes to read
        lenRead = headerSize - METADATA_LENGTH - HEADER_OFFSET_LENGTH;
        internalHeader = new NetFlowHeader(streamVersion, byteOrder, headerSize);
    }

    // allocate buffer for length to read
    headerArray = new byte[lenRead];
    numBytesRead = in.read(headerArray, 0, lenRead);
    if (numBytesRead != lenRead) {
        throw new UnsupportedOperationException("Short read while loading header data");
    }
    // build buffer
    buf = Unpooled.wrappedBuffer(headerArray).order(byteOrder);

    // resolve stream version (either 1 or 3)
    if (streamVersion == 1) {
        internalHeader.setFlowVersion((short) buf.getUnsignedShort(0));
        internalHeader.setStartCapture(buf.getUnsignedInt(2));
        internalHeader.setEndCapture(buf.getUnsignedInt(6));
        internalHeader.setHeaderFlags(buf.getUnsignedInt(10));
        internalHeader.setRotation(buf.getUnsignedInt(14));
        internalHeader.setNumFlows(buf.getUnsignedInt(18));
        internalHeader.setNumDropped(buf.getUnsignedInt(22));
        internalHeader.setNumMisordered(buf.getUnsignedInt(26));
        // Read hostname fixed bytes
        byte[] hostnameBytes = new byte[NetFlowHeader.S1_HEADER_HN_LEN];
        buf.getBytes(30, hostnameBytes, 0, hostnameBytes.length);
        internalHeader.setHostname(new String(hostnameBytes));
        // Read comments fixed bytes
        byte[] commentsBytes = new byte[NetFlowHeader.S1_HEADER_CMNT_LEN];
        buf.getBytes(30 + hostnameBytes.length, commentsBytes, 0, commentsBytes.length);
        internalHeader.setComments(new String(commentsBytes));

        // Dereference arrays
        hostnameBytes = null;
        commentsBytes = null;
    } else {
        // Resolve TLV (type-length value)
        // Set decode pointer to first tlv
        int dp = 0;
        int left = lenRead;
        // Smallest TLV is 2+2+0 (null TLV)
        // tlv_t - TLV type, tlv_l - TLV length, tlv_v - TLV value
        int tlv_t = 0;
        int tlv_l = 0;
        int tlv_v = 0;

        // Byte array for holding Strings
        byte[] pr;

        while (left >= 4) {
            // Parse type, store in host byte order
            tlv_t = buf.getUnsignedShort(dp);
            dp += 2;
            left -= 2;

            // Parse len, store in host byte order
            tlv_l = buf.getUnsignedShort(dp);
            dp += 2;
            left -= 2;

            // Parse val
            tlv_v = dp;

            // Point decode buffer at next tlv
            dp += tlv_l;
            left -= tlv_l;

            // TLV length check
            if (left < 0) {
                break;
            }

            switch (tlv_t) {
            // FT_TLV_VENDOR
            case 0x1:
                internalHeader.setVendor(buf.getUnsignedShort(tlv_v));
                break;
            // FT_TLV_EX_VER
            case 0x2:
                internalHeader.setFlowVersion((short) buf.getUnsignedShort(tlv_v));
                break;
            // FT_TLV_AGG_VER
            case 0x3:
                internalHeader.setAggVersion(buf.getUnsignedByte(tlv_v));
                break;
            // FT_TLV_AGG_METHOD
            case 0x4:
                internalHeader.setAggMethod(buf.getUnsignedByte(tlv_v));
                break;
            // FT_TLV_EXPORTER_IP
            case 0x5:
                internalHeader.setExporterIP(buf.getUnsignedInt(tlv_v));
                break;
            // FT_TLV_CAP_START
            case 0x6:
                internalHeader.setStartCapture(buf.getUnsignedInt(tlv_v));
                break;
            // FT_TLV_CAP_END
            case 0x7:
                internalHeader.setEndCapture(buf.getUnsignedInt(tlv_v));
                break;
            // FT_TLV_HEADER_FLAGS
            case 0x8:
                internalHeader.setHeaderFlags(buf.getUnsignedInt(tlv_v));
                break;
            // FT_TLV_ROT_SCHEDULE
            case 0x9:
                internalHeader.setRotation(buf.getUnsignedInt(tlv_v));
                break;
            // FT_TLV_FLOW_COUNT
            case 0xA:
                internalHeader.setNumFlows(buf.getUnsignedInt(tlv_v));
                break;
            // FT_TLV_FLOW_LOST
            case 0xB:
                internalHeader.setNumDropped(buf.getUnsignedInt(tlv_v));
                break;
            // FT_TLV_FLOW_MISORDERED
            case 0xC:
                internalHeader.setNumMisordered(buf.getUnsignedInt(tlv_v));
                break;
            // FT_TLV_PKT_CORRUPT
            case 0xD:
                internalHeader.setNumCorrupt(buf.getUnsignedInt(tlv_v));
                break;
            // FT_TLV_SEQ_RESET
            case 0xE:
                internalHeader.setSeqReset(buf.getUnsignedInt(tlv_v));
                break;
            // FT_TLV_CAP_HOSTNAME
            case 0xF:
                pr = new byte[tlv_l];
                buf.getBytes(tlv_v, pr, 0, pr.length);
                // Expected null-terminated string
                if (pr[pr.length - 1] != 0) {
                    throw new UnsupportedOperationException("Char sequence is not null-terminated");
                }

                internalHeader.setHostname(new String(pr, 0, pr.length - 1));
                break;
            // FT_TLV_COMMENTS
            case 0x10:
                pr = new byte[tlv_l];
                buf.getBytes(tlv_v, pr, 0, pr.length);
                // Expected null-terminated string
                if (pr[pr.length - 1] != 0) {
                    throw new UnsupportedOperationException("Char sequence is not null-terminated");
                }
                internalHeader.setComments(new String(pr, 0, pr.length - 1));
                break;
            // FT_TLV_IF_NAME
            case 0x11:
                // uint32_t, uint16_t, string:
                // - IP address of device
                // - ifIndex of interface
                // - interface name
                long ip = buf.getUnsignedInt(tlv_v);
                int ifIndex = buf.getUnsignedShort(tlv_v + 4);
                pr = new byte[tlv_l - 4 - 2];
                buf.getBytes(tlv_v + 4 + 2, pr, 0, pr.length);
                if (pr[pr.length - 1] != 0) {
                    throw new UnsupportedOperationException("Char sequence is not null-terminated");
                }
                internalHeader.setInterfaceName(ip, ifIndex, new String(pr, 0, pr.length - 1));
                break;
            // FT_TLV_IF_ALIAS
            case 0x12:
                // uint32_t, uint16_t, uint16_t, string:
                // - IP address of device
                // - ifIndex count
                // - ifIndex of interface (count times)
                // - alias name
                long aliasIP = buf.getUnsignedInt(tlv_v);
                int aliasIfIndexCnt = buf.getUnsignedShort(tlv_v + 4);
                int aliasIfIndex = buf.getUnsignedShort(tlv_v + 4 + 2);
                pr = new byte[tlv_l - 4 - 2 - 2];
                buf.getBytes(tlv_v + 4 + 2 + 2, pr, 0, pr.length);
                if (pr[pr.length - 1] != 0) {
                    throw new UnsupportedOperationException("Char sequence is not null-terminated");
                }

                internalHeader.setInterfaceAlias(aliasIP, aliasIfIndexCnt, aliasIfIndex,
                        new String(pr, 0, pr.length - 1));
                break;
            // Case 0x0
            default:
                break;
            }
        }

        if (buf != null && buf.refCnt() > 0) {
            buf.release(buf.refCnt());
        }

        buf = null;
        pr = null;
    }
    return internalHeader;
}

---

From source file:com.github.sparkfy.network.protocol.MessageWithHeaderSuite.java

License:Apache License

@Test
public void testByteBufBody() throws Exception {
    ByteBuf header = Unpooled.copyLong(42);
    ByteBuf bodyPassedToNettyManagedBuffer = Unpooled.copyLong(84);
    assertEquals(1, header.refCnt());
    assertEquals(1, bodyPassedToNettyManagedBuffer.refCnt());
    ManagedBuffer managedBuf = new NettyManagedBuffer(bodyPassedToNettyManagedBuffer);

    Object body = managedBuf.convertToNetty();
    assertEquals(2, bodyPassedToNettyManagedBuffer.refCnt());
    assertEquals(1, header.refCnt());/*from  ww  w.j a v a2 s . co  m*/

    MessageWithHeader msg = new MessageWithHeader(managedBuf, header, body, managedBuf.size());
    ByteBuf result = doWrite(msg, 1);
    assertEquals(msg.count(), result.readableBytes());
    assertEquals(42, result.readLong());
    assertEquals(84, result.readLong());

    assert (msg.release());
    assertEquals(0, bodyPassedToNettyManagedBuffer.refCnt());
    assertEquals(0, header.refCnt());
}

---

• «
• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8
• 9
• 10
• 11
• 12
• »