When address-full-policy = BLOCK, when is the block actually released?

[bruceas]

I have the following test situation:

1. fast producer, producing homogeneous messages every 1 second

2. slow consumer, consuming these messages every 5 seconds

3. address-full-policy=BLOCK for the appropriate address

I do the following:

1. Start the fast producer; it continues to write messages every 1 second until max-size-bytes is reached, and then is blocked (as expected)

2. Start the slow consumer; it starts to read messages every 5 seconds (as expected)

My expectation was that when the slow consumer would read one message, it would free up space in the queue and the producer would be able to write one message (so every time a message was read, the producer would write another message).

What I observed,however, was that the slow consumer reads a *number* of messages before the producer is unblocked; once unblocked, the producer writes a number of messages until max-size is reached and the process repeats itself.

What exactly controls the unblocking? (e.g. is there a periodic timer that checks the size of the queue and releases the block if space is available? Is there some sort of hystersis inolved [e.g. the free space has to drop back down to 80% of the max-size-bytes before the block is released?])

Thanks

[clebert.suconic]

As soon as you consumed messages.. and Acked messages.. that's when the producer will released.. you have to consume and ack messages (not just consume)

[bruceas]

I'm using AUTO_ACKNOWLEDGE...

[clebert.suconic]

Maybe you have a dead subscription? what won't free up space whatsoever.

Also... take the latest versions.

[bruceas]

Hi Clebert,

Sorry, I wasn't very clear in my original description... let me clarify:

Messages *are* being cleared from the address and the block *is* being released. In general, the overall behavior is exacly what it should be (and is what I expected).

The only confusion I have is that messages appear to be cleared in "chunks":

Suppose that <max-size-bytes> is such that it can hold 100 homogeneous messages. When the producer goes to write the 101st message, the space is full and the producer gets blocked (as expected).

I then start the consumer (which reads at a slower rate than the producer). After the consumer reads one message, my expectation is that there would now be space for one message in the queue so that the block should free, and the producer would be able to write the 101st message (and then get blocked writing the 102nd message, etc.)

However, what I'm seeing is that when I start the consumer, it reads not one, but a "chunk" of messages (say 15) before the block gets released. (At which point the producer is able to write another 15 messages or so until it is blocked again).

So my question is: why does it require that 15 messages (instead of one) be read in order for the block to be released, as the messages are all exactly the same size.

Thank you very much

[clebert.suconic]

Take a look at the consumer Window Size and producer Window Size. They also play on how these things are sent between server and client. You probably need a smaller producer window size if you want an earlier release.

http://docs.jboss.org/hornetq/2.3.0.Alpha/docs/user-manual/html_single/index.html#client-reconnection

[bruceas]

Thanks Clebert. This is exactly what I was looking for. Setting the producer-window-size to -1 gives the behavior that I was expecting.

Thanks again.

[clebert.suconic]

is it still blocking with -1? because I think with -1 you are basicall disabling flow control at the producer. I was expecting 0 to work... but I may be wrong... too much stuff to remember now

[bruceas]

Hi Clebert,

Yes, with -1 you're disabling producer flow control (a producer-window-size of 0 is not valid and causes an error to be logged).

I think that with producer flow control enabled, the server will never send back more credits than would cause the max-size-bytes limit to be exceeded. So either the server is not releasing the block until producer-window-size credits have been made available, or it's releasing the block, but not (initially) sending back enough credits for the producer to add another message. Does this make sense?