roundrobin | simple implementation of round robin | Map library

You can make generator in various ways

inline

You are using wrong shorthand syntax. It must be

You are reusing a single char[] for all of your token parsing. fgets() will overwrite the contents of that char[] each time, and strtok() will return pointers to memory inside of that char[]. Thus, each time you read a new line from the file, the previous pointers you already stored in the process[] array are still pointing at the same memory, but the contents of that memory have been altered.

You need to instead allocate a separate char[] string for each name that you want to save in the process[] array. You can use strdup() for that, eg:

You could do it more simply using ArrayLists or Arrays.

With Arrays, you create 3 int[] and 1 int[][]. What this translates to is "3 arrays of ints and 1 array of arrays of ints". That is what #4 is: an array of your other arrays. In code it is:

The way you configured your HAProxy allows incoming connections to use the PROXY protocol.

What you need to do is configure HAProxy to connect to the backend over the PROXY protocol.

It's just a matter of adding send-proxy-v2 to your server definition as illustrated below:

I believe that some of the fixes that allow the IORegistry to hook the GraphBinary serializer have not yet been released although I do see the work on the main JanusGraph branch. [1] I was having the same problem you reported but was able to get things working using the GraphSONMessageSerialializerV3d0 serializer.

[1] https://github.com/JanusGraph/janusgraph/commit/1cb4b6e849e3f9c2802722fe7f84c760cd471429

This setup code works for me:

Based on our comment exchange, I believe the issue is just that you're running out of resources.

Throughout the lifetime of your app, every time you send a message you open up a brand new socket. However, you're not doing any cleanup after sending that message, and so that socket stays open indefinitely. Your open sockets then continue to pile up, consuming resources, until you eventually run out of... something. Perhaps memory, perhaps ports, perhaps something else, but ultimately your app crashes.

Luckily, the solution isn't too convoluted: just reuse existing sockets. In fact, you can just reuse one socket for the entirety of the application if you wanted, as internally socket.send handles queueing for you, so no need to do any smart hand-offs. However, if you wanted a little more concurrency, here's a quick implementation of a round-robin queue where we've created a pool of 10 sockets in advance which we just grab from whenever we want to send a message:

According to the log, lb service is listening to port 80 inside it's Docker container. Changing the location in nginx.conf to

Even throught this isn't 100% a reply to the question, because I had to switch from HAProxy to NGINX to be able to achieve what I intended, I wanted to leave the solution I found here for others that might find it usefull.

I was able to achieve this using the following configuration: