public void testWriteStreamableList() throws IOException { final int size = randomIntBetween(0, 5); final List<TestStreamable> expected = new ArrayList<>(size); for (int i = 0; i < size; ++i) { expected.add(new TestStreamable(randomBoolean())); } final BytesStreamOutput out = new BytesStreamOutput(); out.writeStreamableList(expected); final StreamInput in = StreamInput.wrap(BytesReference.toBytes(out.bytes())); final List<TestStreamable> loaded = in.readStreamableList(TestStreamable::new); assertThat(loaded, hasSize(expected.size())); for (int i = 0; i < expected.size(); ++i) { assertEquals(expected.get(i).value, loaded.get(i).value); } assertEquals(0, in.available()); in.close(); out.close(); }
@Override public void close() throws IOException { position = valid = 0; if (!closed) { closed = true; doClose(); in.close(); } }
public void testWriteMapOfLists() throws IOException { final int size = randomIntBetween(0, 5); final Map<String, List<String>> expected = new HashMap<>(size); for (int i = 0; i < size; ++i) { int listSize = randomIntBetween(0, 5); List<String> list = new ArrayList<>(listSize); for (int j = 0; j < listSize; ++j) { list.add(randomAsciiOfLength(5)); } expected.put(randomAsciiOfLength(2), list); } final BytesStreamOutput out = new BytesStreamOutput(); out.writeMapOfLists(expected); final StreamInput in = StreamInput.wrap(BytesReference.toBytes(out.bytes())); final Map<String, List<String>> loaded = in.readMapOfLists(); assertThat(loaded.size(), equalTo(expected.size())); for (Map.Entry<String, List<String>> entry : expected.entrySet()) { assertThat(loaded.containsKey(entry.getKey()), equalTo(true)); List<String> loadedList = loaded.get(entry.getKey()); assertThat(loadedList, hasSize(entry.getValue().size())); for (int i = 0; i < loadedList.size(); ++i) { assertEquals(entry.getValue().get(i), loadedList.get(i)); } } assertEquals(0, in.available()); in.close(); out.close(); }
@Override public void messageReceived(ChannelHandlerContext ctx, MessageEvent e) throws Exception { Object m = e.getMessage(); if (!(m instanceof ChannelBuffer)) { ctx.sendUpstream(e); return; } ChannelBuffer buffer = (ChannelBuffer) m; int size = buffer.getInt(buffer.readerIndex() - 4); transportServiceAdapter.received(size + 6); // we have additional bytes to read, outside of the header boolean hasMessageBytesToRead = (size - (NettyHeader.HEADER_SIZE - 6)) != 0; int markedReaderIndex = buffer.readerIndex(); int expectedIndexReader = markedReaderIndex + size; // netty always copies a buffer, either in NioWorker in its read handler, where it copies to a // fresh // buffer, or in the cumlation buffer, which is cleaned each time StreamInput streamIn = ChannelBufferStreamInputFactory.create(buffer, size); long requestId = buffer.readLong(); byte status = buffer.readByte(); Version version = Version.fromId(buffer.readInt()); StreamInput wrappedStream; if (TransportStatus.isCompress(status) && hasMessageBytesToRead && buffer.readable()) { Compressor compressor = CompressorFactory.compressor(buffer); if (compressor == null) { int maxToRead = Math.min(buffer.readableBytes(), 10); int offset = buffer.readerIndex(); StringBuilder sb = new StringBuilder("stream marked as compressed, but no compressor found, first [") .append(maxToRead) .append("] content bytes out of [") .append(buffer.readableBytes()) .append("] readable bytes with message size [") .append(size) .append("] ") .append("] are ["); for (int i = 0; i < maxToRead; i++) { sb.append(buffer.getByte(offset + i)).append(","); } sb.append("]"); throw new ElasticsearchIllegalStateException(sb.toString()); } wrappedStream = CachedStreamInput.cachedHandlesCompressed(compressor, streamIn); } else { wrappedStream = CachedStreamInput.cachedHandles(streamIn); } wrappedStream.setVersion(version); if (TransportStatus.isRequest(status)) { String action = handleRequest(ctx.getChannel(), wrappedStream, requestId, version); if (buffer.readerIndex() != expectedIndexReader) { if (buffer.readerIndex() < expectedIndexReader) { logger.warn( "Message not fully read (request) for [{}] and action [{}], resetting", requestId, action); } else { logger.warn( "Message read past expected size (request) for [{}] and action [{}], resetting", requestId, action); } buffer.readerIndex(expectedIndexReader); } } else { TransportResponseHandler handler = transportServiceAdapter.remove(requestId); // ignore if its null, the adapter logs it if (handler != null) { if (TransportStatus.isError(status)) { handlerResponseError(wrappedStream, handler); } else { handleResponse(ctx.getChannel(), wrappedStream, handler); } } else { // if its null, skip those bytes buffer.readerIndex(markedReaderIndex + size); } if (buffer.readerIndex() != expectedIndexReader) { if (buffer.readerIndex() < expectedIndexReader) { logger.warn( "Message not fully read (response) for [{}] handler {}, error [{}], resetting", requestId, handler, TransportStatus.isError(status)); } else { logger.warn( "Message read past expected size (response) for [{}] handler {}, error [{}], resetting", requestId, handler, TransportStatus.isError(status)); } buffer.readerIndex(expectedIndexReader); } } wrappedStream.close(); }
public void testSimpleStreams() throws Exception { assumeTrue("requires a 64-bit JRE ... ?!", Constants.JRE_IS_64BIT); BytesStreamOutput out = new BytesStreamOutput(); out.writeBoolean(false); out.writeByte((byte) 1); out.writeShort((short) -1); out.writeInt(-1); out.writeVInt(2); out.writeLong(-3); out.writeVLong(4); out.writeOptionalLong(11234234L); out.writeFloat(1.1f); out.writeDouble(2.2); int[] intArray = {1, 2, 3}; out.writeGenericValue(intArray); int[] vIntArray = {4, 5, 6}; out.writeVIntArray(vIntArray); long[] longArray = {1, 2, 3}; out.writeGenericValue(longArray); long[] vLongArray = {4, 5, 6}; out.writeVLongArray(vLongArray); float[] floatArray = {1.1f, 2.2f, 3.3f}; out.writeGenericValue(floatArray); double[] doubleArray = {1.1, 2.2, 3.3}; out.writeGenericValue(doubleArray); out.writeString("hello"); out.writeString("goodbye"); out.writeGenericValue(BytesRefs.toBytesRef("bytesref")); out.writeStringArray(new String[] {"a", "b", "cat"}); out.writeBytesReference(new BytesArray("test")); out.writeOptionalBytesReference(new BytesArray("test")); out.writeOptionalDouble(null); out.writeOptionalDouble(1.2); out.writeTimeZone(DateTimeZone.forID("CET")); out.writeOptionalTimeZone(DateTimeZone.getDefault()); out.writeOptionalTimeZone(null); final byte[] bytes = BytesReference.toBytes(out.bytes()); StreamInput in = StreamInput.wrap(BytesReference.toBytes(out.bytes())); assertEquals(in.available(), bytes.length); assertThat(in.readBoolean(), equalTo(false)); assertThat(in.readByte(), equalTo((byte) 1)); assertThat(in.readShort(), equalTo((short) -1)); assertThat(in.readInt(), equalTo(-1)); assertThat(in.readVInt(), equalTo(2)); assertThat(in.readLong(), equalTo(-3L)); assertThat(in.readVLong(), equalTo(4L)); assertThat(in.readOptionalLong(), equalTo(11234234L)); assertThat((double) in.readFloat(), closeTo(1.1, 0.0001)); assertThat(in.readDouble(), closeTo(2.2, 0.0001)); assertThat(in.readGenericValue(), equalTo((Object) intArray)); assertThat(in.readVIntArray(), equalTo(vIntArray)); assertThat(in.readGenericValue(), equalTo((Object) longArray)); assertThat(in.readVLongArray(), equalTo(vLongArray)); assertThat(in.readGenericValue(), equalTo((Object) floatArray)); assertThat(in.readGenericValue(), equalTo((Object) doubleArray)); assertThat(in.readString(), equalTo("hello")); assertThat(in.readString(), equalTo("goodbye")); assertThat(in.readGenericValue(), equalTo((Object) BytesRefs.toBytesRef("bytesref"))); assertThat(in.readStringArray(), equalTo(new String[] {"a", "b", "cat"})); assertThat(in.readBytesReference(), equalTo(new BytesArray("test"))); assertThat(in.readOptionalBytesReference(), equalTo(new BytesArray("test"))); assertNull(in.readOptionalDouble()); assertThat(in.readOptionalDouble(), closeTo(1.2, 0.0001)); assertEquals(DateTimeZone.forID("CET"), in.readTimeZone()); assertEquals(DateTimeZone.getDefault(), in.readOptionalTimeZone()); assertNull(in.readOptionalTimeZone()); assertEquals(0, in.available()); in.close(); out.close(); }