private int read(Receiver receiver) { //TODO: add pending count to Delivery? int total = 0; int start = 0; while (true) { int read = receiver.recv(_buffer, start, _buffer.length - start); total += read; if (read == (_buffer.length - start)) { //may need to expand the buffer (is there a better test?) byte[] old = _buffer; _buffer = new byte[_buffer.length*2]; System.arraycopy(old, 0, _buffer, 0, old.length); start += read; } else { break; } } return total; }
public int recv(byte[] bytes, int offset, int size) { return getReceiver().recv(bytes, offset, size); }
public static int readDelivery(Receiver receiver, ByteBuf buffer) { int initial = buffer.writerIndex(); // optimization by norman int count; while ((count = receiver.recv(buffer.array(), buffer.arrayOffset() + buffer.writerIndex(), buffer.writableBytes())) > 0) { // Increment the writer index by the number of bytes written into it while calling recv. buffer.writerIndex(buffer.writerIndex() + count); buffer.ensureWritable(count); } return buffer.writerIndex() - initial; }
protected Message decodeIncomingMessage(Delivery incoming) { int count; byte[] chunk = new byte[2048]; ByteArrayOutputStream stream = new ByteArrayOutputStream(); while ((count = getEndpoint().recv(chunk, 0, chunk.length)) > 0) { stream.write(chunk, 0, count); } byte[] messageBytes = stream.toByteArray(); try { Message protonMessage = Message.Factory.create(); protonMessage.decode(messageBytes, 0, messageBytes.length); return protonMessage; } finally { try { stream.close(); } catch (IOException e) { } } }
static Message readMessageFromDelivery(Receiver receiveLink, Delivery delivery) { int msgSize = delivery.pending(); byte[] buffer = new byte[msgSize]; int read = receiveLink.recv(buffer, 0, msgSize); Message message = Proton.message(); message.decode(buffer, 0, read); return message; }
@Override public void onReceiveComplete(Delivery delivery) { final Message response = Proton.message(); final int msgSize = delivery.pending(); final byte[] buffer = new byte[msgSize]; final int read = receiveLink.recv(buffer, 0, msgSize); response.decode(buffer, 0, read); delivery.settle(); final OperationResult<Message, Exception> responseCallback = inflightRequests.remove(response.getCorrelationId()); if (responseCallback != null) responseCallback.onComplete(response); }
@Override public void onReceiveComplete(Delivery delivery) { int msgSize = delivery.pending(); byte[] buffer = new byte[msgSize]; int read = receiveLink.recv(buffer, 0, msgSize); Message message = Proton.message(); message.decode(buffer, 0, read); delivery.settle(); this.prefetchedMessages.add(message); this.underlyingFactory.getRetryPolicy().resetRetryCount(this.getClientId()); this.receiveWork.onEvent(); }
@Override protected void processDelivery(Delivery delivery) { if( !delivery.isReadable() ) { System.out.println("it was not readable!"); return; } if( current==null ) { current = new ByteArrayOutputStream(); } int count; byte data[] = new byte[1024*4]; while( (count = receiver.recv(data, 0, data.length)) > 0 ) { current.write(data, 0, count); } // Expecting more deliveries.. if( count == 0 ) { return; } receiver.advance(); Buffer buffer = current.toBuffer(); current = null; onMessage(delivery, buffer); }
int read = this.receiverLink.recv(buffer, 0, buffer.length);
int read = receiver.recv( buffer, 0, buffer.length ); if (read != size) { throw new IllegalStateException();
private void handlePartial(final Receiver receiver, final Delivery delivery) { if (sessionIncomingCapacity <= 0 || maxFrameSize <= 0 || session.getIncomingBytes() < windowFullThreshhold) { // No window, or there is still capacity, so do nothing. } else { // The session window could be effectively full, we need to // read part of the delivery content to ensure there is // room made for receiving more of the delivery. if(delivery.available() > 0) { ReadableBuffer buff = receiver.recv(); if(splitContent == null && buff instanceof CompositeReadableBuffer) { // Its a composite and there is no prior partial content, use it. splitContent = (CompositeReadableBuffer) buff; } else { int remaining = buff.remaining(); if(remaining > 0) { if (splitContent == null) { splitContent = new CompositeReadableBuffer(); } byte[] chunk = new byte[remaining]; buff.get(chunk); splitContent.append(chunk); } } } } }
@Override public void delivery(Delivery delivery) throws Exception { if (!delivery.isReadable()) { LOG.debug("Delivery was not readable!"); return; } if (current == null) { current = new ByteArrayOutputStream(); } int count; while ((count = getEndpoint().recv(recvBuffer, 0, recvBuffer.length)) > 0) { current.write(recvBuffer, 0, count); if (current.size() > session.getMaxFrameSize()) { throw new AmqpProtocolException("Frame size of " + current.size() + " larger than max allowed " + session.getMaxFrameSize()); } } // Expecting more deliveries.. if (count == 0) { return; } try { processDelivery(delivery, current.toBuffer()); } finally { getEndpoint().advance(); current = null; } }
@Override public void delivery(Delivery delivery) throws Exception { if (!delivery.isReadable()) { LOG.debug("Delivery was not readable!"); return; } if (current == null) { current = new ByteArrayOutputStream(); } int count; while ((count = getEndpoint().recv(recvBuffer, 0, recvBuffer.length)) > 0) { current.write(recvBuffer, 0, count); if (current.size() > session.getMaxFrameSize()) { throw new AmqpProtocolException("Frame size of " + current.size() + " larger than max allowed " + session.getMaxFrameSize()); } } // Expecting more deliveries.. if (count == 0) { return; } try { processDelivery(delivery, current.toBuffer()); } finally { getEndpoint().advance(); current = null; } }
int amount = delivery.pending(); byte[] data = new byte[amount]; receiver.recv(data, 0, amount); receiver.advance();
int read = recv.recv(buffer, 0, buffer.length); recv.advance();
ReadableBuffer data = receiver.recv(); receiver.advance();
@Override public void onMessage(Delivery delivery) throws ActiveMQAMQPException { connection.requireInHandler(); Receiver receiver = ((Receiver) delivery.getLink()); if (receiver.current() != delivery) { return; } if (delivery.isAborted()) { // Aborting implicitly remotely settles, so advance // receiver to the next delivery and settle locally. receiver.advance(); delivery.settle(); // Replenish the credit if not doing a drain if (!receiver.getDrain()) { receiver.flow(1); } return; } else if (delivery.isPartial()) { return; } ReadableBuffer data = receiver.recv(); receiver.advance(); Transaction tx = null; if (delivery.getRemoteState() instanceof TransactionalState) { TransactionalState txState = (TransactionalState) delivery.getRemoteState(); tx = this.sessionSPI.getTransaction(txState.getTxnId(), false); } final Transaction txUsed = tx; actualDelivery(delivery, receiver, data, txUsed); }
message = AmqpCodec.decodeMessage(this, getEndpoint().recv()).asJmsMessage(); } catch (Exception e) { LOG.warn("Error on transform: {}", e.getMessage());
int read = recv.recv(buffer, 0, buffer.length); recv.advance();
ReadableBuffer data = receiver.recv(); if(splitContent != null) { data = completePartial(data);