🎄 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
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.