p2p-sip | Open source peer-to-peer Internet telephony | TCP library

Or does it make more sense to keep NetworkAccess and DeviceModel separate?

As single responsibility principle of SOLID says:

The single-responsibility principle (SRP) is a computer-programming principle that states that every module, class or function in a computer program should have responsibility over a single part of that program's functionality, and it should encapsulate that part. All of that module, class or function's services should be narrowly aligned with that responsibility.

Read more about single responsibility principle of SOLID here.

So making separate method dev.ResetAlarm1() in Device class is more preferable for me.

It is hard to say whether my refactoring code is appropriate to you, but I tried to do my best:

Although the call to ::send() is done sequentially, is the any chance that the byte stream is still mixed?

Of course. Not only there's a chance of that, it is pretty much going to be a certainty, at one point or another. It's going to happen at one point. Guaranteed.

sent to the same socket by different threads

It will be necessary to handle the synchronization at this level, by employing a mutex that each thread locks before sending its message and unlocking it only after the entire message is sent.

It goes without sending that this leaves open a possibility that a blocked/hung socket will result in a single thread locking this mutex for an excessive amount of time, until the socket times out and your execution thread ends up dealing with a failed send() or write(), in whatever fashion it is already doing now (you are, of course, checking the return value from send/write, and handling the exception conditions appropriately).

There is no single, cookie-cutter, paint-by-numbers, solution to this that works in every situation, in every program, that needs to do something like this. Each eventual solution needs to be tailored based on each program's unique requirements and purpose. Just one possibility would be a dedicated execution thread that handles all socket input/output, and all your other execution threads sending their messages to the socket thread, instead of writing to the socket directly. This would avoid having all execution thread wedged by a hung socket, at expense of grown memory, that's holding all unsent data.

But that's just one possible approach. The number of possible, alternative solutions has no limit. You will need to figure out which logic/algorithm based solution will work best for your specific program. There is no operating system/kernel level indication that will give you any kind of a guarantee as to the amount of a send() or write() call on a socket will accept.

Q1 :
"Is it possible to connect to a ZeroMQ-Publisher-Socket WITHOUT implementing or depending on the C++ compiled file of ZeroMQ?"

A1 :
Yes, it is. It is quite enough to re-implement the published ZeroMQ ZMTP RFC-s relevant for the use-case & your code is granted to become interoperable, irrespective of the implementation language / deployment ecosystem, if it meets all the ZMTP RFC-s' mandatory requirements. So it is doable.

Q2 :
"... ZeroMQ uses it's own protocoll (please verify)."

A2 :
No, in the sense of OSI-ISO-L2/L3 stack.
Yes, in the sense of higher layer application-driven protocols, where the ZMTP RFC-s apply for the most of the ZeroMQ Scalable Formal Communication Patterns' Archetypes ( may read more on ZeroMQ sockets are not sockets as you know them ), yet there are also tools to interface with O/S plain-sockets' fd-s, where needed. Still A1 applies here.

Q3 :
"Can I subscribe to a ZeroMQ-Publisher-Socket with ...? If yes, how?"

A3 :
Yes, it possible when your code follows the published ZMTP RFC-s. Implement all ZMTP RFC-s' mandatory properties & you are granted an interoperability with any other, ZeroMQ-ZMTP-RFC-s' compliant, node.

Q4 :
"Are there alternatives?"

A4 :
Yes, if your design can extend the Server-side, adding another AccessPoint-s there, using ZMQ_STREAM Scalable Formal Communication Archetype there, may reduce your Flutter-side scope of ZMTP RFC-s needed, as interfacing to native plain-socket will be the only one to handle and the "functionality gap" thereof can be handled on the Server-side of the link ( easily handling all the subscription management & message filtering, that must meet the ZeroMQ ZMTP RFC-s, so why not tandem it inside the Server-side before connecting the down-stream to Flutter App - smart, isn't it? )

I did this with netlink and INET_DIAG-sockets based on this helpful example: https://github.com/kristrev/inet-diag-example

When you do

You seem to know your problem: the socket object is unavailable. That's 100% by choice. You chose to make it static, of course there will be only one instance.

Also, I hope I am logically correct in making a single TCP client connect to 2 different servers.

It sounds wrong to me. You can redefine "client" to mean something having multiple TCP connections. In that case at the very minimum you expect a container of tcp::socket objects to hold those (or, you know, a Connection object that contains the tcp::socket.

For fun and glory, here's what I think you should be looking for.

Notes:

• no more new, delete
• no more void*, reinterpret casts (!!!)
• less manual buffer sizing/handling
• no more bind
• buffer lifetimes are guaranteed for the corresponding async operations
• message queues per connection
• connections are on a strand for proper synchronized access to shared state in multi-threading environments
• I added in a connection max idle time timeout; it also limits the time taken for any async operation (connect/write). I assumed you wanted something like this because (a) it's common (b) there was an unused deadline_timer in your question code

Note the technique of using shared pointers to have Comm manage its own lifetime. Note also that _socket and _outbox are owned by the individual Comm instance.

Live On Coliru

I think I see what is going on in the source, but i have not run the framework to confirm it.

It looks like mininet inatalls a NAT rule for every node:

In the cloud (AWS. GCP etc.) ARP is emulated by the virtual network layer, meaning that only IPs assigned to VMs by the cloud platform can be resolved. Most of the L2 failover protocols do break for that reason. Even if ARP worked,the IP allocation process for these IPs (often called “floating IPs”) would not integrate with the virtual network in a standard way, so your OS can't just "grab" the IP using ARP and route the packets to itself.

I have not personally done this on Digital Ocean, but I assume that you can call the cloud's proprietary API to do this functionality if you would like to go this route.

See this link on GCP about floating IPs and their implementation. Hope this is helpful.

Here's an idea that needs to be tested:

• Let's say you have Node1(10.1.1.1/24) and Node2(10.1.1.2/24)
• Create a loopback interface on both VMs and set the same IP address for both like (10.2.1.1/32)
• Start a heartbeat send/receive between them
• When NodeA starts it automatically makes an API call to create a route for 10.2.1.1/32 and points to itself with preference 2
• When NodeB starts it automatically makes an API call to create a route for 10.2.1.1/32 and points to itself with preference 1
• The nodes could monitor each other to withdraw the static routes if the other fails. Ideally you would need a 3rd node to reach quorum and prevent split brain scenarios, but you get the idea right?

This seems to be at least in part a bug (or difficult to understand behavior) so I suggest you create an issue on the repo. Perhaps it's related to: Test Error: Assertion failed: Socket operation on non-socket #147.

However, we can do our best to try to understand what's gone wrong and perhaps find a workaround. Since ZMQ.jl uses libzmq to handle sockets on a low level it might interfere with Julia's handling of file descriptors, we may have a race condition. Let's test that hypothesis by modifying your code a bit: