                                                                                                                                                                                                                                                                
Received-SPF: pass (google.com: domain of erlang-questions-boun...@erlang.org designates 192.121.151.104 as permitted sender) client-ip=192.121.151.104;
MIME-Version: 1.0
Date: Fri, 9 Nov 2012 08:20:18 +0300
Message-ID: <CAKLo-1tpM=5PWGL7ESWXCHspB7vAq17NQPUy+tFmEfEfj0Z...@mail.gmail.com>
From: Joshua Muzaaya <joshm...@gmail.com>
To: erlang-questi...@erlang.org
Subject: [erlang-questions] { ProcessName,
 NodeName } ! Message VS rpc:call/4 VS HTTP/1.1 across Erlang Nodes
Precedence: list
Content-Type: multipart/mixed; boundary="===============2670320530201197312=="
Errors-To: erlang-questions-boun...@erlang.org
Sender: erlang-questions-boun...@erlang.org

--===============2670320530201197312==
Content-Type: multipart/alternative; boundary=20cf307cff04812f0004ce091bdb

--20cf307cff04812f0004ce091bdb
Content-Type: text/plain; charset=ISO-8859-1

I have a setup in which two nodes are going to be communicating a lot. On
Node A, there are going to be thousands of processes, which are meant to
access services on Node B. There is going to be a massive load of requests
and responses across the two nodes. The two Nodes, will be running on two
different servers, each on its own hardware server.

I have 3 Options: HTTP/1.1 , rpc:call/4 and Directly sending a message to a
registered gen_server on Node B. Let me explain each option.

*HTTP/1.1*

Suppose that on Node A, i have an HTTP Client like Ibrowse, and on Node B,
i have a web server like Yaws-1.95, the web server being able to handle
unlimited connections, the operating system settings tweaked to allow yaws
to handle all connections. And then make my processes on Node A to
communicate using HTTP. In this case each method call, would mean a single
HTTP request and a reply. I believe there is an overhead here, but we are
evaluating options here. The erlang Built in mechanism called webtool, may
be built for this kind of purpose.

*rpc:call/4*

I could simply make direct rpc calls from Node A to Node B. I am not very
sure how the underlying rpc mechanism works , but i think that when two
erlang nodes connect via net_adm:ping/1, the created connection is not
closed but all rpc calls use this pipe to transmit requests and pass
responses. Please correct me on this one.

*Sending a Message from Node A to Node B *

I could make my processes on Node A to just send message to a registered
process, or a group of processes on Node B. This too seems a clean option.

*Q1.* Which of the above options would you recommend and why, for an
application in which two erlang nodes are going to have enormous
communications between them all the time. Imagine a messaging system, in
which two erlang nodes are the routers :) ?

*Q2.* Which of the above methods is cleaner, less problematic and is more
fault tolerant (i mean here that, the method should NOT have single point
of failure, that could lead to all processes on Node A blind) ?

*Q3.* The mechanism of your choice: how would you make it even more fault
tolerant, or redundant?

*Assumptions: * The Nodes are always alive and will never go down, the
network connection between the nodes will always be available and
non-congested (dedicated to the two nodes only) , the operating system have
allocated maximum resources to these two nodes.

Thank you for your evaluations

--20cf307cff04812f0004ce091bdb
Content-Type: text/html; charset=ISO-8859-1

<br clear="all"><div class="">
        <p>I have a setup in which two nodes are going to be 
communicating a lot. On Node A, there are going to be thousands of 
processes, which are meant to access services on Node B. There is going 
to be a massive load of requests and responses across the two nodes. The
 two Nodes, will be running on two different servers, each on its own 
hardware server.<br><br></p>

<p>I have 3 Options: HTTP/1.1 , rpc:call/4 and Directly sending a 
message to a registered gen_server on Node B. Let me explain each 
option.<br><br>
<b>HTTP/1.1</b><br><br> Suppose that on Node A, i have an HTTP Client like <code>Ibrowse</code>, and on Node B, i have a web server like <code>Yaws-1.95</code>,
 the web server being able to handle unlimited connections, the 
operating system settings tweaked to allow yaws to handle all 
connections. And then make my processes on Node A to communicate using 
HTTP. In this case each method call, would mean a single HTTP request 
and a reply. I believe there is an overhead here, but we are evaluating 
options here. The erlang Built in mechanism called <code>webtool</code>, may be built for this kind of purpose.
<br><br> <b>rpc:call/4</b><br><br> I could simply make direct rpc calls 
from Node A to Node B. I am not very sure how the underlying rpc 
mechanism works , but i think that when two erlang nodes connect via <code>net_adm:ping/1</code>,
 the created connection is not closed but all rpc calls use this pipe to
 transmit requests and pass responses. Please correct me on this one.<br><br><b>Sending a Message from Node A to Node B </b><br><br>
 I could make my processes on Node A to just send message to a 
registered process, or a group of processes on Node B. This too seems a 
clean option.
<br><br>
<b>Q1.</b> Which of the above options would you recommend and why, for 
an application in which two erlang nodes are going to have enormous 
communications between them all the time. Imagine a messaging system, in
 which two erlang nodes are the routers :) ?<br><br> <b>Q2.</b> Which of
 the above methods is cleaner, less problematic and is more fault 
tolerant (i mean here that, the method should NOT have single point of 
failure, that could lead to all processes on Node A blind) ? <br><br><b>Q3.</b> The mechanism of your choice: how would you make it even more fault tolerant, or redundant? <br><br> <b>Assumptions: </b>
 The Nodes are always alive and will never go down, the network 
connection between the nodes will always be available and non-congested 
(dedicated to the two nodes only) , the operating system have allocated 
maximum resources to these two nodes.<br><br> Thank you for your evaluations</p>

    </div><br><br><br><br>

--20cf307cff04812f0004ce091bdb--

--===============2670320530201197312==
Content-Type: text/plain; charset="us-ascii"
MIME-Version: 1.0
Content-Transfer-Encoding: 7bit
Content-Disposition: inline

_______________________________________________
erlang-questions mailing list
erlang-questi...@erlang.org
http://erlang.org/mailman/listinfo/erlang-questions

--===============2670320530201197312==--