file-size | Lightweight filesize to human-readable / proportions | Runtime Evironment library

Doh, I found the issue. I was on the right track with the code using an int rather than a long, but it was my code at fault. I would have expected an error when an int gets set to a value exceeding it's max value but that isn't the case so when the range string was calculated I ended up with;

bytes 2139095040--2124414977/3221225472

when I was expecting;

bytes 2139095040-2170552319/3221225472

I suspect the C# code I was updating came from a sample somewhere on the internet so I guess it's worth leaving this question and answer in place, hopefully it will help someone else that runs into the same issue.

I've taken your simplified configured with just 2 nodes using a non-wildcard queue with redistribution-delay of 0, and I reproduced the behavior you're seeing on my local machine (i.e. without Kubernetes). I believe I see why the behavior is such, but in order to understand the current behavior you first must understand how redistribution works in the first place.

In a cluster every time a consumer is created the node on which the consumer is created notifies every other node in the cluster about the consumer. If other nodes in the cluster have messages in their corresponding queue but don't have any consumers then those other nodes redistribute their messages to the node with the consumer (assuming the message-load-balancing is ON_DEMAND and the redistribution-delay is >= 0).

In your case however, the node with the messages is actually down when the consumer is created on the other node so it never actually receives the notification about the consumer. Therefore, once that node restarts it doesn't know about the other consumer and does not redistribute its messages.

I see you've opened ARTEMIS-3321 to enhance the broker to deal with this situation. However, that will take time to develop and release (assuming the change is approved). My recommendation to you in the mean-time would be to configure your client reconnection which is discussed in the documentation, e.g.:

In general, this concept should be easily achievable with microservices and a suiting configuration. And yes, you should be able to use profiles to define different database connections so that you can have multiple instances running.

I assume you are overwriting temporary build artifacts, that's why it is not working somehow. But that is hard to diagnose from distance. You might consider using Docker containers with a suiting configuration to increase isolation in this regard.

First, it's important to note that there's no feature to make a client reconnect to the broker from which it disconnected after the client crashes/restarts. Generally speaking the client shouldn't really care about what broker it connects to; that's one of the main goals of horizontal scalability.

It's also worth noting that if the number of messages on the brokers and the number of connected clients is low enough that this condition arises frequently that almost certainly means you have too many brokers in your cluster.

That said, I believe the reason that your client isn't getting the messages it expects is because you're using the default redistribution-delay (i.e. -1) which means messages will not be redistributed to other nodes in the cluster. If you want to enable redistribution (which is seems like you do) then you should set it to >= 0, e.g.:

perhaps you can use a click event:

How to set default image in dropify ? ( base64 image format )

To set default image in dropify using a base64 encoded image that is stored in your database, you can refer to the following approach.

This kind of behavior is expected when sending non-durable messages because non-durable messages are sent in a non-blocking manner. It's not clear whether or not you're sending non-durable messages, but you've also set blockOnDurableSend=false on your client's URL so even durable messages will be sent non-blocking.

From the broker's perspective the messages haven't actually arrived so there's no way to see the number of messages that have been sent but are not yet in the queue.

If you want to ensure that when the Camel route terminates all messages are written to the queue then you should send durable messages and set blockOnDurableSend=true (which is the default value).

Keep in mind that blocking will reduce performance (potentially substantially) based on the speed of you hard disk. This is because the client will have to wait for a response from the broker for every message it sends, and for every message the broker receives it will have to persist that message to disk and wait for the hard disk to sync before it sends a response back to the client. Therefore, if your hard disk can't sync quickly the client will have to wait a long time relatively speaking.

One of the configuration parameters that influences this behavior is journal-buffer-timeout. This value is calculated automatically and set when the broker instance is first created. You'll see evidence of this logged, e.g.:

You don't need to save image. This is how you send images to discord without saving it:

I tried by making a fetch call and calculated the size of the file from blob.

But downside is, we cant know the size of the file until its completely loaded as the response headers of the given mp3 url didnt have any info related to size.

Here I have set the audio data after its fetched to the audio element, but this is not necessary. I just added it to play the audio file.

(You will have to wait till the file has loaded to see result after pressing Run code snippet.)