Q regarding multicast and n-way connection in a cluster
I am relatively new to really getting into Erlang as opposed to just reading
every available article about it ;-).
So far I used to be involved with building clustered (business) solutions
that have employed a technique that seems not to be exactly in line with the
Erlang way of architecting such systems.
I'd appreciate if someone could illustrate for me how an Erlang architect
would build a "clustered stateful service". Let's assume that each client
has a little bit of state (some kB) and that there could be many thousand
concurrent clients hitting the cluster. Because of the large workload that
the large number of clients generates, the cluster might have to get rather
large (e.g. 10 to 50 machines). Also we do not want to pass the state back
and forth between the client and the server but only pass a session
identifier (e.g. as part of a http cookie).
For cluster membership I am used to use heartbeats over IP multicast, where
each cluster member uses the same multicast address to publish the heartbeat
information. Heartbeats can carry all sorts of data (e.g. a servers current
load, etc.). Also each server packs its "views" of who else is in the
cluster into the heartbeat that is seen by everybody else. This avoids the
need for a centralized "member registry".
Q1: how could I elegantly access the socket layer to send/listen on a
It seemed to me that a cluster of n Erlang nodes will "implicitly" n-way
interconnect if I have to use message sends from each server to each other
server to maintain the cluster membership protocol. While this seems
feasible for smaller clusters, I would get nervous about scalability if the
cluster contains maybe 100s of machines (I would "waist" those socket
resources for something that I could use 1 multicast socket for).
Q2: where can I find information as to how the various Erlang constructs
(e.g. process links across nodes) translate to "OS resource usage". I am
specifically interested in whether inter node communication is multiplexed
through a single socket per node-pair (or is there a socket per process or
even per send)?
Q3: are "process links across nodes" implemented by detecting the breaking
of a TCP connection or is there a heartbeat/timeout involved for the
point2point connection as well?
Thanks for you help and pointer to "implementation level documentation"!