while(true) { while( currentBuffer !=null ) { if( sender.getCredit() > 0 ) { int sent = sender.send(currentBuffer.data, currentBuffer.offset, currentBuffer.length); currentBuffer.moveHead(sent); if( currentBuffer.length == 0 ) { Delivery current = currentDelivery; MessageDelivery md = (MessageDelivery) current.getContext(); currentBuffer = null; currentDelivery = null; if( qos == QoS.AT_MOST_ONCE ) { current.settle(); } else { sender.advance(); currentBuffer = md.encoded(); if( qos == QoS.AT_MOST_ONCE ) { currentDelivery = sender.delivery(EMPTY_BYTE_ARRAY, 0, 0); } else { final byte[] tag = nextTag(); currentDelivery = sender.delivery(tag, 0, tag.length); currentDelivery.setContext(md);
public Sender create(Session session) { Sender sender = session.sender(_path); Target target = new Target(); target.setAddress(_path); sender.setTarget(target); // the C implemenation does this: Source source = new Source(); source.setAddress(_path); sender.setSource(source); if (getOutgoingWindow() > 0) { // use explicit settlement via dispositions (not pre-settled) sender.setSenderSettleMode(SenderSettleMode.UNSETTLED); sender.setReceiverSettleMode(ReceiverSettleMode.SECOND); // desired } return sender; } }
public void addSender(Sender sender) throws Exception { ProtonServerSenderContext protonSender = new ProtonServerSenderContext(connection, sender, this, sessionSPI); try { protonSender.initialise(); senders.put(sender, protonSender); serverSenders.put(protonSender.getBrokerConsumer(), protonSender); sender.setContext(protonSender); sender.open(); protonSender.start(); } catch (ActiveMQAMQPException e) { senders.remove(sender); sender.setSource(null); sender.setCondition(new ErrorCondition(e.getAmqpError(), e.getMessage())); sender.close(); } }
/** * Sends a Message on the senderLink * @param tag delivery tag * @param data Data to be sent on the link * @param length Length of the data * @param offset Offset of the data to send */ public void sendMessage(byte[] tag, byte[] data, int length, int offset) { this.senderLink.delivery(tag); this.senderLink.send(data, offset, length); this.senderLink.advance(); }
/** * Creates a new AmqpSender instance that manages the given Sender * * @param session * the AmqpSession object that is the parent of this instance. * @param endpoint * the AMQP Sender instance that this class manages. * @param consumerInfo * the ConsumerInfo instance that holds configuration for this sender. */ public AmqpSender(AmqpSession session, Sender endpoint, ConsumerInfo consumerInfo) { super(session, endpoint); // We don't support second so enforce it as First and let remote decide what to do this.endpoint.setReceiverSettleMode(ReceiverSettleMode.FIRST); // Match what the sender mode is this.endpoint.setSenderSettleMode(endpoint.getRemoteSenderSettleMode()); this.consumerInfo = consumerInfo; this.presettle = getEndpoint().getSenderSettleMode() == SenderSettleMode.SETTLED; }
@Override public void onEvent() { if (sendLink != null && sendLink.getLocalState() != EndpointState.CLOSED) { sendLink.close(); } else if (sendLink == null || sendLink.getRemoteState() == EndpointState.CLOSED) { if (closeTimer != null && !closeTimer.isCancelled()) { closeTimer.cancel(false); } linkClose.complete(null); } } });
Source source = new Source(); source.setAddress(senderId); source.setOutcomes(outcomes); sender.setSource(source); sender.setTarget(target); sender.setSenderSettleMode(userSpecifiedSenderSettlementMode); if (SenderSettleMode.SETTLED.equals(userSpecifiedSenderSettlementMode)) { presettle = true; sender.setSenderSettleMode(SenderSettleMode.SETTLED); } else { sender.setSenderSettleMode(SenderSettleMode.UNSETTLED); sender.setReceiverSettleMode(userSpecifiedReceiverSettlementMode); } else { sender.setReceiverSettleMode(ReceiverSettleMode.FIRST); sender.setDesiredCapabilities(desiredCapabilities); sender.setOfferedCapabilities(offeredCapabilities); sender.setProperties(properties);
Target sednerTarget = new Target(); sednerTarget.setAddress(this.linkPath); sender.setTarget(sednerTarget); Source senderSource = new Source(); senderSource.setAddress(this.replyTo); sender.setSource(senderSource); sender.setSenderSettleMode(SenderSettleMode.SETTLED); sender.setProperties(commonLinkProperties); SendLinkHandler sendLinkHandler = new SendLinkHandler(this.amqpSender); BaseHandler.setHandler(sender, sendLinkHandler); receiveLinkNamePrefix; Receiver receiver = session.receiver(receiveLinkName); Source receiverSource = new Source(); receiverSource.setAddress(this.linkPath); receiver.setSource(receiverSource); sender.open(); this.underlyingFactory.registerForConnectionError(sender); TRACE_LOGGER.debug("RequestReponseLink - opening receive link to {}", this.linkPath);
private void executeDelivery(MessageReference messageReference) { if (sender.getLocalState() == EndpointState.CLOSED) { log.debug("Not delivering message " + messageReference + " as the sender is closed and credits were available, if you see too many of these it means clients are issuing credits and closing the connection with pending credits a lot of times"); return; delivery = sender.delivery(tag, 0, tag.length); delivery.setMessageFormat((int) message.getMessageFormat()); delivery.setContext(messageReference); sender.send(sendBuffer); } else { sender.sendNoCopy(sendBuffer); log.debug(e.getMessage(), e); delivery.settle(); } else { sender.advance();
private void createSender(org.apache.qpid.proton.engine.Session session) throws Exception { Sender sender = session.sender(subscriberInfo.getClientId()); Target target = new Target(); target.setAddress(subscriberInfo.getClientAddress()); sender.setTarget(target); Source source = new Source(); source.setAddress(subscriberInfo.getClientAddress()); source.setDurable(TerminusDurability.UNSETTLED_STATE); sender.setSource(source); sender.open(); } }
sender.setSenderSettleMode(SenderSettleMode.SETTLED); Source source = new Source(); source.setAddress(senderName); source.setOutcomes(outcomes); sender.setSource(source); sender.setTarget(target); sender.setContext(amqpSender); sender.open();
private void doSend(AmqpMessage message, AsyncResult request, AmqpTransactionId txId) throws Exception { LOG.trace("Producer sending message: {}", message); Delivery delivery = null; if (presettle) { delivery = getEndpoint().delivery(EMPTY_BYTE_ARRAY, 0, 0); } else { byte[] tag = tagGenerator.getNextTag(); delivery = getEndpoint().delivery(tag, 0, tag.length); } delivery.setContext(request); Binary amqpTxId = null; if (txId != null) { amqpTxId = txId.getRemoteTxId(); } else if (session.isInTransaction()) { amqpTxId = session.getTransactionId().getRemoteTxId(); } if (amqpTxId != null) { TransactionalState state = new TransactionalState(); state.setTxnId(amqpTxId); delivery.disposition(state); } encodeAndSend(message.getWrappedMessage(), delivery); if (presettle) { delivery.settle(); request.onSuccess(); } else { pending.add(delivery); getEndpoint().advance(); } }
@Override public void onDelivery(Event event) { Delivery delivery = event.getDelivery(); while (delivery != null) { Sender sender = (Sender) delivery.getLink(); TRACE_LOGGER.debug("onDelivery: linkName:{}, unsettled:{}, credit:{}, deliveryState:{}, delivery.isBuffered:{}, delivery.tag:{}", sender.getName(), sender.getUnsettled(), sender.getRemoteCredit(), delivery.getRemoteState(), delivery.isBuffered(), delivery.getTag()); msgSender.onSendComplete(delivery); delivery.settle(); delivery = sender.current(); } }
boolean preSettle = sender.getRemoteSenderSettleMode() == SenderSettleMode.SETTLED; delivery = sender.delivery(tag, 0, tag.length); delivery.setContext(context); sender.send(nettyBuffer.array(), nettyBuffer.arrayOffset() + nettyBuffer.readerIndex(), nettyBuffer.readableBytes()); delivery.settle(); sender.advance();
private int pumpOut( String address, Sender sender ) { StoreEntry entry = _outgoingStore.get( address ); if (entry == null) { sender.drained(); return 0; } byte[] tag = String.valueOf(_nextTag++).getBytes(); Delivery delivery = sender.delivery(tag); entry.setDelivery( delivery ); _logger.log(Level.FINE, "Sending on delivery: " + delivery); int n = sender.send( entry.getEncodedMsg(), 0, entry.getEncodedLength()); if (n < 0) { _outgoingStore.freeEntry( entry ); _logger.log(Level.WARNING, "Send error: " + n); return n; } else { sender.advance(); _outgoingStore.freeEntry( entry ); return 0; } }
@Override public void accept(Session session) { if (MessageSender.this.getIsClosingOrClosed()) { session.close(); return; } final Sender sender = session.sender(TrackingUtil.getLinkName(session)); final Target target = new Target(); target.setAddress(sendPath); sender.setTarget(target); final Source source = new Source(); sender.setSource(source); sender.setSenderSettleMode(SenderSettleMode.UNSETTLED); final SendLinkHandler handler = new SendLinkHandler(MessageSender.this); BaseHandler.setHandler(sender, handler); if (MessageSender.this.sendLink != null) { MessageSender.this.underlyingFactory.deregisterForConnectionError(MessageSender.this.sendLink); } MessageSender.this.underlyingFactory.registerForConnectionError(sender); sender.open(); synchronized (MessageSender.this.errorConditionLock) { MessageSender.this.sendLink = sender; } } };
public void declare(AmqpTransactionId txId, AsyncResult request) throws Exception { if (txId.getRemoteTxId() != null) { throw new IllegalStateException("Declare called while a TX is still Active."); } if (isClosed()) { request.onFailure(new JMSException("Cannot start new transaction: Coordinator remotely closed")); return; } Message message = Message.Factory.create(); Declare declare = new Declare(); message.setBody(new AmqpValue(declare)); Delivery pendingDelivery = getEndpoint().delivery(tagGenerator.getNextTag()); pendingDelivery.setContext(txId); // Store away for completion pendingDeliveries.add(pendingDelivery); pendingRequests.put(txId, request); sendTxCommand(message); }
private void createSendLink(SenderLinkSettings linkSettings) { TRACE_LOGGER.info("Creating send link to '{}'", this.sendPath); final Connection connection = this.underlyingFactory.getConnection(); final Session session = connection.session(); session.setOutgoingWindow(Integer.MAX_VALUE); session.open(); BaseHandler.setHandler(session, new SessionHandler(sendPath)); final Sender sender = session.sender(linkSettings.linkName); sender.setTarget(linkSettings.target); sender.setSource(linkSettings.source); sender.setProperties(linkSettings.linkProperties); TRACE_LOGGER.debug("Send link settle mode '{}'", linkSettings.settleMode); sender.setSenderSettleMode(linkSettings.settleMode); SendLinkHandler handler = new SendLinkHandler(CoreMessageSender.this); BaseHandler.setHandler(sender, handler); sender.open(); this.sendLink = sender; this.underlyingFactory.registerForConnectionError(this.sendLink); }