Pass control from one gen_fsm to another

Question

I'm creating a generic Erlang server that should be able to handle hundreds of client connections concurrently. For simplicity, let's suppose that the server performs for every client some basic computation, e.g., addition or subtraction of every two values which the client provides.

As a starting point, I'm using this tutorial for basic TCP client-server interaction. An excerpt that represents the supervision tree:

                +----------------+
                | tcp_server_app |
                +--------+-------+
                         | (one_for_one)
        +----------------+---------+
        |                          |
+-------+------+           +-------+--------+
| tcp_listener |           + tcp_client_sup |
+--------------+           +-------+--------+
                                   | (simple_one_for_one)
                             +-----|---------+
                           +-------|--------+|
                          +--------+-------+|+
                          |  tcp_echo_fsm  |+
                          +----------------+

I would like to extend this code and allow tcp_echo_fsm to pass the control over the socket to one out of two modules: tcp_echo_addition (to compute the addition of every two client values), or tcp_echo_subtraction (to compute the subtraction between every two client values).

The tcp_echo_fsm would choose which module to handle a socket based on the first message from the client, e.g., if the client sends <<start_addition>>, then it would pass control to tcp_echo_addition.

The previous diagram becomes:

                +----------------+
                | tcp_server_app |
                +--------+-------+
                         | (one_for_one)
        +----------------+---------+
        |                          |
+-------+------+           +-------+--------+
| tcp_listener |           + tcp_client_sup |
+--------------+           +-------+--------+
                                   | (simple_one_for_one)
                             +-----|---------+
                           +-------|--------+|
                          +--------+-------+|+
                          |  tcp_echo_fsm  |+
                          +----------------+
                                  |
                                  |
                 +----------------+---------+
         +-------+-----------+      +-------+--------------+
         | tcp_echo_addition |      + tcp_echo_subtraction |
         +-------------------+      +-------+--------------+

My questions are:

Am I on the right path? Is the tutorial which I'm using a good starting point for a scalable TCP server design?
How can I pass control from one gen_fsm (namely, tcp_echo_fsm) to another gen_fsm (either tcp_echo_addition or tcp_echo_subtraction)? Or better yet: is this a correct/clean way to design the server? This related question suggests that passing control between a gen_fsm and another module is not trivial and there might be something wrong with this approach.

score 3 · Accepted Answer · answered Jul 13 '15 at 20:04

3

For 2, you can use gen_tcp:controlling_process/2 to pass control of the tcp connection: http://erlang.org/doc/man/gen_tcp.html#controlling_process-2.

For 1, I am not sure of the value of spawning a new module as opposed to handling the subtraction and addition logic as part of the defined states in your finite state machine. Doing so creates code which is now running outside of your supervision tree, so it's harder to handle errors and restarts. Why not define addition and subtraction as different states within your state machines handle that logic within those two states?

You can create tcp_echo_fsm:subtraction_state/2,3 and tcp_echo_fsm:addition_state/2,3 to handle this logic and use your first message to transition to the appropriate state rather than adding complexity to your application.

answered Jul 13 '15 at 20:04

dethtron5000

10,363
1
31
32

1. I want different gen_fsm to handle addition and subtraction because I'd like the design to be extensible. For instance, I'd like to be able to add any kind of computation (multiplication, addition of 3 subsequent numbers, and so on..). It would be unwieldy to have all this logic in a single gen_fsm. This opinion of mine was reinforced once I saw this related [post](https://stackoverflow.com/questions/10024758/change-gen-fsm-state-to-a-function-in-a-different-module). For 2: thanks, I'll have a look. – adizere Jul 13 '15 at 20:42
@adizere that makes sense, but it's kind of hard to answer definitively since it's going to depend a lot on your specific application. One thing to consider is using `gen_server`s instead of `gen_fsm`s, if the behavior your `tcp_echo_*` functions aren't state-dependent. You should also look at what happens in the supervision tree when you spawn a new `tcp_echo_*` function - you'll need to dynamically add them via `supervisor:start_child/2`. – dethtron5000 Jul 14 '15 at 03:13
I think I'll go with `gen_server`s instead of `gen_fsm`s and see what happens. I'm following now [this tutorial](http://learnyousomeerlang.com/buckets-of-sockets#sockserv-revisited). – adizere Jul 14 '15 at 09:06
For completeness: I ended up switching to `gen_server`s instead of `gen_fsm`, and I have a common module (`tcp_echo_server`) calling the functions of one of the operation-specific modules. This removes the need for differentiated processes -- all tcp_echo_servers are the same, but they call functions from different modules, based on the requested type of operations. – adizere Jul 21 '15 at 13:47

Pass control from one gen_fsm to another

1 Answers1