Erlang and OTP in Action.pdf - Synrc

112
I use telnet to connect via TCP on port 1055 to my now running tr_server. Once
connected I run the following command obeying our protocol, really Erlangs protocol,
init:stop(). This should result in a function call of the form init:stop(), or actually, apply(init,
stop, []), being generated and called. Since init:stop/0 returns the atom ok we expect to
see the string “ok” sent back to our telnet session – which we do again. The next thing we
see is “Connection closed by foreign host”. This is printed by the telnet utility because the
socket it was connected to was close by the server, our Erlang VM. The reason for that is
that the function init:stop() shuts down ERTS. Wonderful in that we have just demonstrated
that our RPC server works and we have also shown just how dangerous it can be! That was
a meaty section. We have built in just a few lines of code a very powerful application that is
quite useful in the real world.
3.4 – Summary
We have covered quite a bit in this chapter. We have learned a little more about
processes, modules, functions, and messages. We have also learned about behaviours and
the three parts that make them what they are the:
1. Behaviour Interface
2. Behaviour Implementation
3. Behaviour Container
We have covered the gen_server behaviour specifically at some depth and we did this all
through a real world example in our tcp_rpc service. In the next chapter we are going to
take our little stand alone generic RPC server and we are going to hook it into a structure
that is going to render it enterprise grade. We are going to hook it into an OTP application.
Once that is complete our little server will be part of an application that is versioned, fault
tolerant, ready for use by others in their projects, and ready to go to production. Chapter 4
will take what you have learned in Chapter 2 and here in chapter 3 and will add on another
layer in the basic understanding of Erlang/OTP as a framework by teaching you the
fundamental fault tolerant structure, the supervisor, and by teaching you how to roll up your
functionality into nice OTP packages. From there we will refine that understanding in
Chapter 5 explaining the theory behind some of the things you have taken for granted up
until that point. Once that is complete we will be ready to move on into creating something
seriously powerful Erlang software.
©Manning Publications Co. Please post comments or corrections to the Author Online forum:
http://www.manning-sandbox.com/forum.jspaforumID=454