epoll | epoll binding in Ruby | Networking library

The ArtemisCloud container image for ActiveMQ Artemis is designed to run inside a container so the container IP address should be used to access to the console or to other resources.

The container IP address can be obtained by using the command docker inspect or by reading the container log, ie:

So there are multiple issues.

First of in PacketDecoder you need to first check if there are 4 bytes readable before trying to call byteBuf.readInt(). So something like:

epoll itself does not associate a specific callback with a file descriptor. It just returns via epoll_wait on which file descriptors an event occurred and which kind of event. It is fully up to the application on what to do with this information, like handle it directly in the same function where epoll_wait was called, call a single function a() for all Epollin events or call different functions a(), b(), .... for Epollin on different file desriptors.

From the linux unix(7) man page:

The send(2) MSG_MORE flag is not supported by UNIX domain sockets.

and also of interest:

The SO_SNDBUF socket option does have an effect for UNIX domain sockets, but the SO_RCVBUF option does not.

So there's no point in using MSG_MORE in your code; it's for TCP and UDP sockets.

Also, the number of reads on a stream (Be it a TCP socket, UNIX domain socket, pipe, etc.) isn't related to the number of writes on the far end. You have to include things like message boundaries in a higher-level protocol that uses the stream. If doing that is an issue, you might look into a SOCK_SEQPACKET unix socket instead, combined with writev(2) to send scattered data (I think that'll cause all the data to be in a single packet).

At a high level IPThreadPoolExecutors should be used only if you need a pool of EventBases. If you need a pool of workers, then use CPUThreadPoolExecutor.

Contains a series of priority queues which get constantly picked up by a series of workers. Each worker thread executes threadRun() after created. ThreadRun() is essentially an infinite loop which pulls one task from task queue and executes it. If the task is already expired when it is fetched, then the expire callback is executed instead of the task itself.

Each IO thread runs its own EventBase. Instead of pulling task from task queue like the CPUThreadPoolExecutor, the IOThreadPoolExecutor registers an event to the EventBase of next IO thread. Each IO thread then calls loopForEver() for its EventBase, which essentially calls epoll() to perform async io.

So most of the time you should probably be using a CPUThreadPoolExecutor, as that is the usual use case for having a pool of workers.

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

When you add spring security to an application you automatically get a default security setup, which is described here in the spring security documentation.

But as soon as you declare a custom security configuration, then you are basically on your own.

What is missing in the above configuration is to explicitly configure that you want http basic authentication.

this is done by adding:

Turns out issue was in broker.xml configuration. In static-connectors I somehow decided to list only a "non-current server" (e.g. I have srv0 and srv1 - in srv0 I only added connector of srv1 and vice versa).

What it used to be (on 1st master node):

select and friends are syscalls. To use select and friends, at one point, Rust needs to call those syscalls. Those syscalls are not expressed in Rust, they use C semantics (when calling them via libc), or assembly (when calling them directly).

From the perspective of Rust that means they're unsafe, the Rust compiler has no way to know what they're doing at all.

That means in order to use them from rust you have two choices:

• call them directly, using unsafe
• or use a higher-level package which ends up calling them (internally using unsafe), like tokio

Even if there were a (linux-only) pure-rust and rust-targeted reinvention of libc, it would ultimately have to use unsafe in order to craft the actual syscalls and call into the kernel. So would a hypothetical pure-rust bare-metal unikernel.