/** * Decodes the client connection preface string from the input buffer. * * @return {@code true} if processing of the client preface string is complete. Since client * preface strings can only be received by servers, returns true immediately for client * endpoints. */ private boolean readClientPrefaceString(ByteBuf in) throws Http2Exception { if (clientPrefaceString == null) { return true; } int prefaceRemaining = clientPrefaceString.readableBytes(); int bytesRead = min(in.readableBytes(), prefaceRemaining); // If the input so far doesn't match the preface, break the connection. if (bytesRead == 0 || !ByteBufUtil.equals( in, in.readerIndex(), clientPrefaceString, clientPrefaceString.readerIndex(), bytesRead)) { String receivedBytes = hexDump( in, in.readerIndex(), min(in.readableBytes(), clientPrefaceString.readableBytes())); throw connectionError( PROTOCOL_ERROR, "HTTP/2 client preface string missing or corrupt. " + "Hex dump for received bytes: %s", receivedBytes); } in.skipBytes(bytesRead); clientPrefaceString.skipBytes(bytesRead); if (!clientPrefaceString.isReadable()) { // Entire preface has been read. clientPrefaceString.release(); clientPrefaceString = null; return true; } return false; }
public boolean decodeHeader( final ByteBuf buf, InetSocketAddress recipient, final InetSocketAddress sender) { if (message == null) { if (buf.readableBytes() < MessageHeaderCodec.HEADER_SIZE) { // we don't have the header yet, we need the full header first // wait for more data return false; } message = MessageHeaderCodec.decodeHeader(buf, recipient, sender); } if (message.sender().isNet4Private() && buf.readableBytes() < MessageHeaderCodec.HEADER_PRIVATE_ADDRESS_SIZE) { return false; } else if (message.sender().isNet4Private() && buf.readableBytes() >= MessageHeaderCodec.HEADER_PRIVATE_ADDRESS_SIZE) { PeerSocketAddress internalPeerSocketAddress = PeerSocketAddress.create(buf, true); message.sender(message.sender().changeInternalPeerSocketAddress(internalPeerSocketAddress)); } // we have set the content types already message.presetContentTypes(true); for (Content content : message.contentTypes()) { if (content == Content.EMPTY) { break; } if (content == Content.PUBLIC_KEY_SIGNATURE) { message.setHintSign(); } contentTypes.offer(content); } LOG.debug("Parsed message {}.", message); return true; }
@Override public int onDataRead( ChannelHandlerContext ctx, int streamId, ByteBuf data, int padding, boolean endOfStream) throws Http2Exception { FullHttpMessage msg = messageMap.get(streamId); if (msg == null) { throw connectionError( PROTOCOL_ERROR, "Data Frame received for unknown stream id %d", streamId); } ByteBuf content = msg.content(); final int dataReadableBytes = data.readableBytes(); if (content.readableBytes() > maxContentLength - dataReadableBytes) { throw connectionError( INTERNAL_ERROR, "Content length exceeded max of %d for stream id %d", maxContentLength, streamId); } content.writeBytes(data, data.readerIndex(), dataReadableBytes); if (endOfStream) { fireChannelRead(ctx, msg, streamId); } // All bytes have been processed. return dataReadableBytes + padding; }
@Override protected void decode(ChannelHandlerContext ctx, ByteBuf in, List<Object> out) throws Exception { long frameLength = decodeLength(in, 0); if (frameLength > maxFrameLength) { long discard = frameLength - in.readableBytes(); tooLongFrameLength = frameLength; if (discard < 0) { // buffer contains more bytes then the frameLength so we can discard all now in.skipBytes((int) frameLength); } else { // Enter the discard mode and discard everything received so far. discardingTooLongFrame = true; bytesToDiscard = discard; in.skipBytes(in.readableBytes()); } failIfNecessary(true); } else { int readerIndex = in.readerIndex(); int actualFrameLength = (int) frameLength; ByteBuf buffer = extractFrame(ctx, in, readerIndex, actualFrameLength); in.readerIndex(readerIndex + actualFrameLength); out.add(buffer); } }
protected void internalReceive(HttpResponseStatus status, HttpHeaders headers, ByteBuf content) { try { if (status.code() > 399) { byte[] b = new byte[content.readableBytes()]; content.readBytes(b); onErrorResponse(status, headers, new String(b, CharsetUtil.UTF_8)); return; } if (type == ByteBuf.class) { _doReceive(status, headers, type.cast(content)); } else if (type == String.class || type == CharSequence.class) { byte[] b = new byte[content.readableBytes()]; content.readBytes(b); _doReceive(status, headers, type.cast(new String(b, CharsetUtil.UTF_8))); } else if (type == byte[].class) { byte[] b = new byte[content.readableBytes()]; content.readBytes(b); _doReceive(status, headers, type.cast(b)); } else { ObjectMapper mapper = new ObjectMapper(); byte[] b = new byte[content.readableBytes()]; content.readBytes(b); try { Object o = mapper.readValue(b, type); _doReceive(status, headers, type.cast(o)); } catch (Exception ex) { Exceptions.chuck(ex); } } } finally { latch.countDown(); } }
@Override public void addContent(ByteBuf buffer, boolean last) throws IOException { if (buffer != null) { long localsize = buffer.readableBytes(); if (definedSize > 0 && definedSize < size + localsize) { throw new IOException("Out of size: " + (size + localsize) + " > " + definedSize); } size += localsize; if (byteBuf == null) { byteBuf = buffer; } else if (byteBuf instanceof CompositeByteBuf) { CompositeByteBuf cbb = (CompositeByteBuf) byteBuf; cbb.addComponent(buffer); cbb.writerIndex(cbb.writerIndex() + buffer.readableBytes()); } else { CompositeByteBuf cbb = compositeBuffer(); cbb.addComponents(byteBuf, buffer); cbb.writerIndex(byteBuf.readableBytes() + buffer.readableBytes()); byteBuf = cbb; } } if (last) { completed = true; } else { if (buffer == null) { throw new NullPointerException("buffer"); } } }
@Override public Subobject parseSubobject(final ByteBuf buffer, final boolean loose) throws PCEPDeserializerException { Preconditions.checkArgument( buffer != null && buffer.isReadable(), "Array of bytes is mandatory. Can't be null or empty."); if (buffer.readableBytes() < HEADER_LENGTH) { throw new PCEPDeserializerException( "Wrong length of array of bytes. Passed: " + buffer.readableBytes() + "; Expected: >" + HEADER_LENGTH + "."); } final BitArray reserved = BitArray.valueOf(buffer, FLAGS_SIZE); final short cType = buffer.readUnsignedByte(); final LabelType labelType = this.registry.parseLabel(cType, buffer.slice()); if (labelType == null) { throw new PCEPDeserializerException( "Unknown C-TYPE for ero label subobject. Passed: " + cType); } final LabelBuilder builder = new LabelBuilder(); builder.setUniDirectional(reserved.get(U_FLAG_OFFSET)); builder.setLabelType(labelType); return new SubobjectBuilder() .setLoose(loose) .setSubobjectType(new LabelCaseBuilder().setLabel(builder.build()).build()) .build(); }
@Override protected void decode(ChannelHandlerContext ctx, ByteBuf in, List<Object> out) throws Exception { // System.out.println("decode:" + in.readableBytes()); if (in.readableBytes() > 4) { in.markReaderIndex(); int needBytes = in.readInt(); // System.out.println("needBytes:" + needBytes); if (in.readableBytes() >= needBytes) { byte[] content = new byte[in.readableBytes()]; in.readBytes(content); // byte[] data= ZLipHelper.decompress(content); // System.out.println("data:" + new String(data)); Amf3Input amf3Input = new Amf3Input(SerializationContext.getSerializationContext()); // amf3Input = new Amf3Input(SerializationContext.getSerializationContext()); InputStream bais = new ByteArrayInputStream(content); amf3Input.setInputStream(bais); try { Object decoded = amf3Input.readObject(); if (decoded != null) { out.add(decoded); // System.out.println("decoded:" + decoded); } } catch (Exception e) { } // amf3Input.close(); } else { in.resetReaderIndex(); } } }
@Override protected void decode(ChannelHandlerContext ctx, ByteBuf in, List<Object> out) throws Exception { Protocol.DirectionData prot = this.server ? this.protocol.TO_SERVER : this.protocol.TO_CLIENT; ByteBuf copy = in.copy(); try { int packetId = DefinedPacket.readVarInt(in); DefinedPacket packet = null; if (prot.hasPacket(packetId)) { packet = prot.createPacket(packetId); packet.read(in, prot.getDirection(), this.protocolVersion); if (in.readableBytes() != 0) { throw new BadPacketException( "Did not read all bytes from packet " + packet.getClass() + " " + packetId + " Protocol " + this.protocol + " Direction " + prot); } } else { in.skipBytes(in.readableBytes()); } out.add(new PacketWrapper(packet, copy)); copy = null; } finally { if (copy != null) { copy.release(); } } }
private void write(ByteBuf buff, boolean end) { int readableBytes = buff.readableBytes(); if (readableBytes == 0 && !end) { // nothing to write to the connection just return return; } if (end) { completed = true; } if (!end && !chunked && !contentLengthSet()) { throw new IllegalStateException( "You must set the Content-Length header to be the total size of the message " + "body BEFORE sending any data if you are not using HTTP chunked encoding."); } written += buff.readableBytes(); if (conn == null) { if (pendingChunks == null) { pendingChunks = buff; } else { CompositeByteBuf pending; if (pendingChunks instanceof CompositeByteBuf) { pending = (CompositeByteBuf) pendingChunks; } else { pending = Unpooled.compositeBuffer(); pending.addComponent(pendingChunks).writerIndex(pendingChunks.writerIndex()); pendingChunks = pending; } pending.addComponent(buff).writerIndex(pending.writerIndex() + buff.writerIndex()); } connect(); } else { if (!headWritten) { writeHeadWithContent(buff, end); } else { if (end) { if (buff.isReadable()) { conn.writeToChannel(new DefaultLastHttpContent(buff, false)); } else { conn.writeToChannel(LastHttpContent.EMPTY_LAST_CONTENT); } } else { conn.writeToChannel(new DefaultHttpContent(buff)); } } if (end) { conn.reportBytesWritten(written); if (respHandler != null) { conn.endRequest(); } } } }
private SpdyHeadersFrame readHeaderBlockFrame(ByteBuf buffer) { int streamId; switch (type) { case SPDY_SYN_STREAM_FRAME: if (buffer.readableBytes() < 10) { return null; } int offset = buffer.readerIndex(); streamId = getUnsignedInt(buffer, offset); int associatedToStreamId = getUnsignedInt(buffer, offset + 4); byte priority = (byte) (buffer.getByte(offset + 8) >> 5 & 0x07); buffer.skipBytes(10); length -= 10; SpdySynStreamFrame spdySynStreamFrame = new DefaultSpdySynStreamFrame(streamId, associatedToStreamId, priority); spdySynStreamFrame.setLast((flags & SPDY_FLAG_FIN) != 0); spdySynStreamFrame.setUnidirectional((flags & SPDY_FLAG_UNIDIRECTIONAL) != 0); return spdySynStreamFrame; case SPDY_SYN_REPLY_FRAME: if (buffer.readableBytes() < 4) { return null; } streamId = getUnsignedInt(buffer, buffer.readerIndex()); buffer.skipBytes(4); length -= 4; SpdySynReplyFrame spdySynReplyFrame = new DefaultSpdySynReplyFrame(streamId); spdySynReplyFrame.setLast((flags & SPDY_FLAG_FIN) != 0); return spdySynReplyFrame; case SPDY_HEADERS_FRAME: if (buffer.readableBytes() < 4) { return null; } streamId = getUnsignedInt(buffer, buffer.readerIndex()); buffer.skipBytes(4); length -= 4; SpdyHeadersFrame spdyHeadersFrame = new DefaultSpdyHeadersFrame(streamId); spdyHeadersFrame.setLast((flags & SPDY_FLAG_FIN) != 0); return spdyHeadersFrame; default: throw new Error("Shouldn't reach here."); } }
/** * Transfers data from the original message to the channel, encrypting it in the process. * * <p>This method also breaks down the original message into smaller chunks when needed. This is * done to keep memory usage under control. This avoids having to copy the whole message data * into memory at once, and can avoid ballooning memory usage when transferring large messages * such as shuffle blocks. * * <p>The {@link #transfered()} counter also behaves a little funny, in that it won't go forward * until a whole chunk has been written. This is done because the code can't use the actual * number of bytes written to the channel as the transferred count (see {@link #count()}). * Instead, once an encrypted chunk is written to the output (including its header), the size of * the original block will be added to the {@link #transfered()} amount. */ @Override public long transferTo(final WritableByteChannel target, final long position) throws IOException { Preconditions.checkArgument(position == transfered(), "Invalid position."); long reportedWritten = 0L; long actuallyWritten = 0L; do { if (currentChunk == null) { nextChunk(); } if (currentHeader.readableBytes() > 0) { int bytesWritten = target.write(currentHeader.nioBuffer()); currentHeader.skipBytes(bytesWritten); actuallyWritten += bytesWritten; if (currentHeader.readableBytes() > 0) { // Break out of loop if there are still header bytes left to write. break; } } actuallyWritten += target.write(currentChunk); if (!currentChunk.hasRemaining()) { // Only update the count of written bytes once a full chunk has been written. // See method javadoc. long chunkBytesRemaining = unencryptedChunkSize - currentReportedBytes; reportedWritten += chunkBytesRemaining; transferred += chunkBytesRemaining; currentHeader.release(); currentHeader = null; currentChunk = null; currentChunkSize = 0; currentReportedBytes = 0; } } while (currentChunk == null && transfered() + reportedWritten < count()); // Returning 0 triggers a backoff mechanism in netty which may harm performance. Instead, // we return 1 until we can (i.e. until the reported count would actually match the size // of the current chunk), at which point we resort to returning 0 so that the counts still // match, at the cost of some performance. That situation should be rare, though. if (reportedWritten != 0L) { return reportedWritten; } if (actuallyWritten > 0 && currentReportedBytes < currentChunkSize - 1) { transferred += 1L; currentReportedBytes += 1L; return 1L; } return 0L; }
@Override public ByteBuf translateFrame(ByteBuf readBuffer) throws LimitExedeedException, InvalidDataException { while (readBuffer.isReadable()) { switch (status) { case STATUS_H: h = readBuffer.readByte(); status = STATUS_L; break; case STATUS_L: l = readBuffer.readByte(); final int blen = Protocol.order == ByteOrder.BIG_ENDIAN ? (0x0000ff00 & (h << 8)) | (0x000000ff & l) : (0x0000ff00 & (l << 8)) | (0x000000ff & h); if (context != null) { if (blen <= 0 || blen > maxFrameSize) { throw new LimitExedeedException("帧长度非法:" + h + "/" + l + ":" + blen); } } incompleteframe = PooledByteBufAllocator.DEFAULT.buffer(blen + 16 + 2); incompleteframe = incompleteframe.order(Protocol.order); incompleteframe.writeShort(blen); status = STATUS_C; break; case STATUS_C: int len = incompleteframe.writableBytes() - 16; len = len < readBuffer.readableBytes() ? len : readBuffer.readableBytes(); // incompleteframe.writeBytes(readBuffer, len); if (readBuffer.hasMemoryAddress()) { PlatformDependent.copyMemory( readBuffer.memoryAddress() + readBuffer.readerIndex(), incompleteframe.memoryAddress() + incompleteframe.writerIndex(), len); } else if (readBuffer.hasArray()) { PlatformDependent.copyMemory( readBuffer.array(), readBuffer.arrayOffset() + readBuffer.readerIndex(), incompleteframe.memoryAddress() + incompleteframe.writerIndex(), len); } incompleteframe.writerIndex(incompleteframe.writerIndex() + len); readBuffer.readerIndex(readBuffer.readerIndex() + len); if ((incompleteframe.writableBytes() - 16) <= 0) { status = STATUS_H; return incompleteframe; } break; } } return null; }
@Override public final void flushNow() { if (inFlushNow || flushTaskInProgress != null) { return; } inFlushNow = true; ChannelHandlerContext ctx = directOutboundContext(); Throwable cause = null; try { if (ctx.hasOutboundByteBuffer()) { ByteBuf out = ctx.outboundByteBuffer(); int oldSize = out.readableBytes(); try { doFlushByteBuffer(out); } catch (Throwable t) { cause = t; } finally { final int newSize = out.readableBytes(); final int writtenBytes = oldSize - newSize; if (writtenBytes > 0) { flushFutureNotifier.increaseWriteCounter(writtenBytes); if (newSize == 0) { out.discardReadBytes(); } } } } else { MessageBuf<Object> out = ctx.outboundMessageBuffer(); int oldSize = out.size(); try { doFlushMessageBuffer(out); } catch (Throwable t) { cause = t; } finally { flushFutureNotifier.increaseWriteCounter(oldSize - out.size()); } } if (cause == null) { flushFutureNotifier.notifyFlushFutures(); } else { flushFutureNotifier.notifyFlushFutures(cause); if (cause instanceof IOException) { close(voidFuture()); } } } finally { inFlushNow = false; } }
private Object readControlFrame(ByteBuf buffer) { int streamId; int statusCode; switch (type) { case SPDY_RST_STREAM_FRAME: if (buffer.readableBytes() < 8) { return null; } streamId = getUnsignedInt(buffer, buffer.readerIndex()); statusCode = getSignedInt(buffer, buffer.readerIndex() + 4); buffer.skipBytes(8); return new DefaultSpdyRstStreamFrame(streamId, statusCode); case SPDY_PING_FRAME: if (buffer.readableBytes() < 4) { return null; } int ID = getSignedInt(buffer, buffer.readerIndex()); buffer.skipBytes(4); return new DefaultSpdyPingFrame(ID); case SPDY_GOAWAY_FRAME: if (buffer.readableBytes() < 8) { return null; } int lastGoodStreamId = getUnsignedInt(buffer, buffer.readerIndex()); statusCode = getSignedInt(buffer, buffer.readerIndex() + 4); buffer.skipBytes(8); return new DefaultSpdyGoAwayFrame(lastGoodStreamId, statusCode); case SPDY_WINDOW_UPDATE_FRAME: if (buffer.readableBytes() < 8) { return null; } streamId = getUnsignedInt(buffer, buffer.readerIndex()); int deltaWindowSize = getUnsignedInt(buffer, buffer.readerIndex() + 4); buffer.skipBytes(8); return new DefaultSpdyWindowUpdateFrame(streamId, deltaWindowSize); default: throw new Error("Shouldn't reach here."); } }
/** * Load a string from the given buffer, reading first the two bytes of len and then the UTF-8 * bytes of the string. * * @return the decoded string or null if NEED_DATA */ static String decodeString(ByteBuf in) throws UnsupportedEncodingException { if (in.readableBytes() < 2) { return null; } // int strLen = Utils.readWord(in); int strLen = in.readUnsignedShort(); if (in.readableBytes() < strLen) { return null; } byte[] strRaw = new byte[strLen]; in.readBytes(strRaw); return new String(strRaw, "UTF-8"); }
@Override public ByteBuf readPacket() throws IOException { Preconditions.checkState(!mClosed, "PacketReader is closed while reading packets."); ByteBuf buf = null; mLock.lock(); try { while (true) { if (mDone) { return null; } if (mPacketReaderException != null) { throw new IOException(mPacketReaderException); } buf = mPackets.poll(); // TODO(peis): Have a better criteria to resume so that we can have fewer state changes. if (!tooManyPacketsPending()) { resume(); } // Queue is empty. if (buf == null) { try { if (!mNotEmptyOrFailed.await(READ_TIMEOUT_MS, TimeUnit.MILLISECONDS)) { throw new IOException( String.format("Timeout while reading packet from block %d @ %s.", mId, mAddress)); } } catch (InterruptedException e) { throw Throwables.propagate(e); } } else { if (buf.readableBytes() == 0) { buf.release(); mDone = true; return null; } mPosToRead += buf.readableBytes(); Preconditions.checkState(mPosToRead - mStart <= mBytesToRead); return buf; } } } catch (Throwable e) { if (buf != null) { buf.release(); } throw e; } finally { mLock.unlock(); } }
@Override public void writeData(ByteBuf data) { super.writeData(data); ByteBuf tmpState = Unpooled.buffer(); tmpState.writeByte(stateList.size()); for (StateWithId stateWithId : stateList) { tmpState.writeByte(stateWithId.stateId); stateWithId.state.writeData(tmpState); } data.writeInt(tmpState.readableBytes()); data.writeBytes(tmpState.readBytes(tmpState.readableBytes())); }
private void testCompress0(ZlibWrapper encoderWrapper, ZlibWrapper decoderWrapper, ByteBuf data) throws Exception { EmbeddedChannel chEncoder = new EmbeddedChannel(createEncoder(encoderWrapper)); chEncoder.writeOutbound(data.copy()); chEncoder.flush(); EmbeddedChannel chDecoderZlib = new EmbeddedChannel(createDecoder(decoderWrapper)); for (; ; ) { ByteBuf deflatedData = chEncoder.readOutbound(); if (deflatedData == null) { break; } chDecoderZlib.writeInbound(deflatedData); } byte[] decompressed = new byte[data.readableBytes()]; int offset = 0; for (; ; ) { ByteBuf buf = chDecoderZlib.readInbound(); if (buf == null) { break; } int length = buf.readableBytes(); buf.readBytes(decompressed, offset, length); offset += length; buf.release(); if (offset == decompressed.length) { break; } } assertEquals(data, Unpooled.wrappedBuffer(decompressed)); assertNull(chDecoderZlib.readInbound()); // Closing an encoder channel will generate a footer. assertTrue(chEncoder.finish()); for (; ; ) { Object msg = chEncoder.readOutbound(); if (msg == null) { break; } ReferenceCountUtil.release(msg); } // But, the footer will be decoded into nothing. It's only for validation. assertFalse(chDecoderZlib.finish()); data.release(); }
@Override public void fatalError(String message, String stack) { if (log.isDebugEnabled()) { log.debug("Sending HTTP error due to script error {}", message); } StringBuilder msg = new StringBuilder(message); if (stack != null) { msg.append('\n'); msg.append(stack); } ByteBuf data = Unpooled.copiedBuffer(msg, Charsets.UTF8); response.setStatus(HttpResponseStatus.INTERNAL_SERVER_ERROR); response.headers().add("Content-Type", "text/plain"); response.headers().add("Content-Length", data.readableBytes()); calculateKeepAlive(true); channel.write(response); DefaultHttpContent chunk = new DefaultHttpContent(data); channel.write(chunk); sendLastChunk(); channel.flush(); if (!keepAlive) { shutDown(); } }
public NettyMessage decode(ByteBuf in) throws Exception { NettyMessage message = new NettyMessage(); Header header = new Header(); header.setCrcCode(in.readInt()); header.setLength(in.readInt()); header.setSessionID(in.readLong()); header.setType(in.readByte()); header.setPriority(in.readByte()); int size = in.readInt(); if (size > 0) { Map<String, Object> attch = new HashMap<String, Object>(size); int keySize = 0; byte[] keyArray = null; String key = null; for (int i = 0; i < size; i++) { keySize = in.readInt(); keyArray = new byte[keySize]; in.readBytes(keyArray); key = new String(keyArray, "UTF-8"); attch.put(key, marshallingDecoder.decode(in)); } keyArray = null; key = null; header.setAttachment(attch); } if (in.readableBytes() > 4) { message.setBody(marshallingDecoder.decode(in)); } message.setHeader(header); return message; }
public ByteBuf encode(NettyMessage msg) throws Exception { ByteBuf sendBuf = Unpooled.buffer(); sendBuf.writeInt((msg.getHeader().getCrcCode())); sendBuf.writeInt((msg.getHeader().getLength())); sendBuf.writeLong((msg.getHeader().getSessionID())); sendBuf.writeByte((msg.getHeader().getType())); sendBuf.writeByte((msg.getHeader().getPriority())); sendBuf.writeInt((msg.getHeader().getAttachment().size())); String key = null; byte[] keyArray = null; Object value = null; for (Map.Entry<String, Object> param : msg.getHeader().getAttachment().entrySet()) { key = param.getKey(); keyArray = key.getBytes("UTF-8"); sendBuf.writeInt(keyArray.length); sendBuf.writeBytes(keyArray); value = param.getValue(); marshallingEncoder.encode(value, sendBuf); } key = null; keyArray = null; value = null; if (msg.getBody() != null) { marshallingEncoder.encode(msg.getBody(), sendBuf); } else sendBuf.writeInt(0); sendBuf.setInt(4, sendBuf.readableBytes()); return sendBuf; }
private void handleChunk( HttpContent chunk, // final Channel channel, // final NettyResponseFuture<?> future, // AsyncHandler<?> handler) throws IOException, Exception { boolean interrupt = false; boolean last = chunk instanceof LastHttpContent; // Netty 4: the last chunk is not empty if (last) { LastHttpContent lastChunk = (LastHttpContent) chunk; HttpHeaders trailingHeaders = lastChunk.trailingHeaders(); if (!trailingHeaders.isEmpty()) { interrupt = handler.onHeadersReceived(new HttpResponseHeaders(trailingHeaders, true)) != State.CONTINUE; } } ByteBuf buf = chunk.content(); if (!interrupt && !(handler instanceof StreamedAsyncHandler) && (buf.readableBytes() > 0 || last)) { HttpResponseBodyPart part = config.getResponseBodyPartFactory().newResponseBodyPart(buf, last); interrupt = updateBodyAndInterrupt(future, handler, part); } if (interrupt || last) finishUpdate(future, channel, !last); }
@Override public boolean renameTo(File dest) throws IOException { if (dest == null) { throw new NullPointerException("dest"); } if (byteBuf == null) { // empty file dest.createNewFile(); isRenamed = true; return true; } int length = byteBuf.readableBytes(); FileOutputStream outputStream = new FileOutputStream(dest); FileChannel fileChannel = outputStream.getChannel(); int written = 0; if (byteBuf.nioBufferCount() == 1) { ByteBuffer byteBuffer = byteBuf.nioBuffer(); while (written < length) { written += fileChannel.write(byteBuffer); } } else { ByteBuffer[] byteBuffers = byteBuf.nioBuffers(); while (written < length) { written += fileChannel.write(byteBuffers); } } fileChannel.force(false); fileChannel.close(); outputStream.close(); isRenamed = true; return written == length; }
@Override protected void encode(ChannelHandlerContext chc, SubscribeMessage message, ByteBuf out) { if (message.subscriptions().isEmpty()) { throw new IllegalArgumentException("Found a subscribe message with empty topics"); } if (message.getQos() != AbstractMessage.QOSType.LEAST_ONE) { throw new IllegalArgumentException( "Expected a message with QOS 1, found " + message.getQos()); } ByteBuf variableHeaderBuff = chc.alloc().buffer(4); ByteBuf buff = null; try { variableHeaderBuff.writeShort(message.getMessageID()); for (SubscribeMessage.Couple c : message.subscriptions()) { variableHeaderBuff.writeBytes(Utils.encodeString(c.topicFilter)); variableHeaderBuff.writeByte(c.qos); } int variableHeaderSize = variableHeaderBuff.readableBytes(); byte flags = Utils.encodeFlags(message); buff = chc.alloc().buffer(2 + variableHeaderSize); buff.writeByte(AbstractMessage.SUBSCRIBE << 4 | flags); buff.writeBytes(Utils.encodeRemainingLength(variableHeaderSize)); buff.writeBytes(variableHeaderBuff); out.writeBytes(buff); } finally { variableHeaderBuff.release(); buff.release(); } }
public void consumePacket(ByteBuf data) { int cnt = data.readableBytes() / 4; dimensions = new int[cnt]; for (int i = 0; i < cnt; i++) { dimensions[i] = data.readInt(); } }
public Response(int id, int recipientID, String recipient, ByteBuf payload) { this.id = id; this.size = 20 + payload.readableBytes(); this.recipientID = recipientID; this.recipient = recipient; this.payload = payload; }
@Override public OFMeterFeaturesStatsReply readFrom(ByteBuf bb) throws OFParseError { int start = bb.readerIndex(); // fixed value property version == 5 byte version = bb.readByte(); if (version != (byte) 0x5) throw new OFParseError("Wrong version: Expected=OFVersion.OF_14(5), got=" + version); // fixed value property type == 19 byte type = bb.readByte(); if (type != (byte) 0x13) throw new OFParseError("Wrong type: Expected=OFType.STATS_REPLY(19), got=" + type); int length = U16.f(bb.readShort()); if (length != 32) throw new OFParseError("Wrong length: Expected=32(32), got=" + length); if (bb.readableBytes() + (bb.readerIndex() - start) < length) { // Buffer does not have all data yet bb.readerIndex(start); return null; } if (logger.isTraceEnabled()) logger.trace("readFrom - length={}", length); long xid = U32.f(bb.readInt()); // fixed value property statsType == 11 short statsType = bb.readShort(); if (statsType != (short) 0xb) throw new OFParseError( "Wrong statsType: Expected=OFStatsType.METER_FEATURES(11), got=" + statsType); Set<OFStatsReplyFlags> flags = OFStatsReplyFlagsSerializerVer14.readFrom(bb); // pad: 4 bytes bb.skipBytes(4); OFMeterFeatures features = OFMeterFeaturesVer14.READER.readFrom(bb); OFMeterFeaturesStatsReplyVer14 meterFeaturesStatsReplyVer14 = new OFMeterFeaturesStatsReplyVer14(xid, flags, features); if (logger.isTraceEnabled()) logger.trace("readFrom - read={}", meterFeaturesStatsReplyVer14); return meterFeaturesStatsReplyVer14; }
@Override public OFInstructionIdBsnAutoNegotiation readFrom(ByteBuf bb) throws OFParseError { int start = bb.readerIndex(); // fixed value property type == 65535 short type = bb.readShort(); if (type != (short) 0xffff) throw new OFParseError( "Wrong type: Expected=OFInstructionType.EXPERIMENTER(65535), got=" + type); int length = U16.f(bb.readShort()); if (length != 12) throw new OFParseError("Wrong length: Expected=12(12), got=" + length); if (bb.readableBytes() + (bb.readerIndex() - start) < length) { // Buffer does not have all data yet bb.readerIndex(start); return null; } if (logger.isTraceEnabled()) logger.trace("readFrom - length={}", length); // fixed value property experimenter == 0x5c16c7L int experimenter = bb.readInt(); if (experimenter != 0x5c16c7) throw new OFParseError( "Wrong experimenter: Expected=0x5c16c7L(0x5c16c7L), got=" + experimenter); // fixed value property subtype == 0xbL int subtype = bb.readInt(); if (subtype != 0xb) throw new OFParseError("Wrong subtype: Expected=0xbL(0xbL), got=" + subtype); if (logger.isTraceEnabled()) logger.trace("readFrom - returning shared instance={}", INSTANCE); return INSTANCE; }
@Override public void appendMessages(Tpp tpp, Collection<MessageBatchWithRawData> batches) throws Exception { ByteBuf bodyBuf = Unpooled.buffer(); KafkaMessageBrokerSender sender = getSender(tpp.getTopic()); try { for (MessageBatchWithRawData batch : batches) { List<PartialDecodedMessage> pdmsgs = batch.getMessages(); for (PartialDecodedMessage pdmsg : pdmsgs) { m_messageCodec.encodePartial(pdmsg, bodyBuf); byte[] bytes = new byte[bodyBuf.readableBytes()]; bodyBuf.readBytes(bytes); bodyBuf.clear(); ByteBuf propertiesBuf = pdmsg.getDurableProperties(); HermesPrimitiveCodec codec = new HermesPrimitiveCodec(propertiesBuf); Map<String, String> propertiesMap = codec.readStringStringMap(); sender.send(tpp.getTopic(), propertiesMap.get("pK"), bytes); BrokerStatusMonitor.INSTANCE.kafkaSend(tpp.getTopic()); } } } finally { bodyBuf.release(); } }