Message-Broker | pure NodeJS implementation of a simple pub | Pub Sub library

Solution 1 (all in python script): Try to use Thread and Queue.

I do this:

These settings should get you that 'prefer local' behavior you want:

decreaseNetworkConsumerPriority="true" suppressDuplicateQueueSubscriptions="true"

Also, add messagTTL = 4 and consumerTTL = 1. This allows messages to hop around n + 1 times. (Where n is the number of brokers in your cluster). Also, consumerTTL = 1 means brokers will only see consumers from their immediate peer, and not see over multiple hops.

In your use case, drop the networkTTL setting-- messageTTl and consumerTTL replace it and give you more control over message hops and consumer awareness.

I found the reason by myself. Though there might be many issues with 'clientinbounchannel', in my case It was just a simple problem caused by difference of versions between spring framework dependencies added in pom.xml. Especially 'spring-messaging'. So if anyone encountered the same issue of mine or any other, please check your pom.xml once again just in case.

I was able to figure it out. All I had to do was this:

The prefetchPolicy doesn't apply to ActiveMQ Artemis. It's for ActiveMQ 5.x.

The consumerWindowSize does apply to ActiveMQ Artemis.

However, neither prefetchPolicy nor consumerWindowSize apply to this situation as they're both related to "flow control" and have nothing to do with putting "missed" messages onto a JMS topic subscription.

The "retroactive consumer" feature is for ActiveMQ 5.x. A similar feature (called "retroactive address") will be available in ActiveMQ Artemis 2.11. It was implemented as part of ARTEMIS-2504.

Therefore you have a few options:

1. Wait for ActiveMQ Artemis 2.11 to be released (should be released in January).
2. Build your own version of ActiveMQ Artemis based on the master branch which includes the retroactive address feature.
3. Modify your test environment so that new subscribers don't have to wait so long for messages (e.g. send them more frequently).

The issue come from the way Windows interpret the npm library, I advise you to switch to a Linux or Mac environment..

There are multiple ways of doing this. What you could do is create a new Shadow-component that is a child of Page (or whatever is your actual root component). This Shadow is then given a state prop that tells the component whether to render the shadow-div or not.

All this is pretty easy. The most complex part is usually to come up with some sensible state management system so that you can trigger the Shadow without passing the "enable shadow" handler all around. I suggest to check out Redux for this.

Use z-index style to make sure the shadow appears between the Page and the modal. For Example shadow z-index 1, modal container 2. Also, make sure both shadow and the modal container are positioned as absolute as they both should overlay the page.

Here's a pseudo-simplification:

Most message brokers allow both synchronous and asynchronous API. First you have to decide which API to use: synchronous or asynchronous. Synchronous is simpler, but uses blocking I/O operations. Blocking operation blocks a thread, and you have to keep as many threads as how many you have waiting I/O operations. Since each thread consumes significant amount of core memory, there is natural limit about 10000 threads per Java process. So first evaluate if you can afford to use synchronous API, and if yes, use it.

If the number of simultaneously circulating messages in one JVM exceeds 10000, then you have to use asynchronous API and asynchronous processing of messages. Actors are only one kind of asynchronous processing units. Others are CompletableFuture's from standard java, Observers from RxJava and other reactive libraries, or usually message brokers offer their own ways of asynchronous processing. Look at all that asynchronous libraries and choose what you like more.

I would like to know if my understanding of Message Bus and Message Queue workings is correct.

Some comments/answers. This is not going to be comprehensive as many aspects are specific to the queue being used.

a service bus is used interchangeably with message bus?

Right. A service bus is a message bus infrastructure used in service-oriented solution, providing the back-end data transport mechanism between the services.

It is a publisher-subscriber type of system where messages are added let's say to a message collection by any number of publishers and from where any number of subscribers can read

There are generally two models:

1) Publish/Subscribe, where a publisher sends data to a bus without a specific target in mind. One or more subscribers can then consume the message (or not, see below).

2) Request/Response, where a senders sends the data to the bus but expects a specific received to handle the message and return a response.

how does a subscriber know what message it is interested in...?

Most service bus implementations use the concept of routing keys. Each data entity sent to the bus is accompanied by a key that the subscribers can then filter by.

Of course, subscribers may also choose to get all messages posted to a particular queue.

How does the subscriber receives the message ?

This varies among service queue products. In RabbitMQ, for example, messages are delivered to a subscriber by the API whereas in Kafka, the client must poll the server periodically for messages.

when is a message removed from MESSAGE-COLLECTION?

Sometimes not at all. This also varies both between products and configurations. Sometimes a message is delivered to only one receiver and is deleted once delivery has been confirmed, but sometimes messages are left on the bus until they are expired based on a time stamp. Many scenarios are possible.