🎄 Happy Holidays! 🥳

Most of Solace is closed December 24–January 1 so our employees can spend time with their families. We will re-open Thursday, January 2, 2024. Please expect slower response times during this period and open a support ticket for anything needing immediate assistance.

Happy Holidays!

Please note: most of Solace is closed December 25–January 2, and will re-open Tuesday, January 3, 2023.

JCSMP Blocking Publisher Example: Timeout configurable

ChristianHoltfurth
ChristianHoltfurth Member, Employee Posts: 75 Solace Employee

Hi Community,

I have a question on the JCSMP BlockingSynchronousSendGuaranteed.java sample:

What happens, if the broker doesn't respond with either an ACK or a NACK?

Is this even possible or under which conditions could that occur?

(I read something about disk full could be one potential situation.)


Is there a timeout for how long the call will block?

In the comments I can see that PUB_ACK_TIME is set to 2000ms after which the API would retransmit a message. But does it ever timeout and return control to the application, if the broker isn't responding with an ACK or a NACK?

// asynchronous send method and associated event callbacks. Calls to blockingSend() can

// block indefinitely waiting for receipt of an ACK or NACK for the message sent.

// If the API fails to receive either an ACK or NACK from the broker within the

// the JCSMPProperties.PUB_ACK_TIME timeout (default 2000ms) the API retransmits the

// message. The API will retransmit the message every JCSMPProperties.PUB_ACK_TIME milliseconds

// until an ACK or NACK is received. Typically the broker only fails to respond with an ACK

// or NACK if it is out of disk space to persist the received message.

//

// This method uses a CyclicBarrier to synchronize between sending the message and receiving

// either an ACK, in the ResponseReceivedEx callback, or a NACK, in the

// handleErrorEx callback.

public synchronized void blockingSend(XMLMessage message, Topic topic) throws Exception {

publishException = null;

CyclicBarrier barrier = new CyclicBarrier(2);

message.setCorrelationKey(barrier);

producer.send(message, topic);




try {

barrier.await();

} catch (InterruptedException e) {

throw(e);

} catch (BrokenBarrierException e) {

throw(e);

}




if (publishException != null) {

throw publishException;

}

}
// This is the blocking, synchronous send method implemented using the JCSMP API's non-blocking,

This sounds like a potential rare edge case, but I'm curious what would happen in this situation.