Erlang/OTP实践指南：从基础到生产系统

5星 · 超过95%的资源需积分: 10 61 浏览量更新于2024-07-23 收藏 6.87MB PDF 举报

Erlang和OTP实践指南 Erlang是函数式编程语言，OTP（Open Telecom Platform）是Erlang语言的应用平台，旨在实现高可用性、可扩展性和高性能的系统。下面是根据给定的文件信息，总结出的相关知识点。 Erlang语言基础 ---------------- Erlang语言是一种函数式编程语言，具有高级别的抽象性和可扩展性。Erlang语言的基础知识点包括： * Erlang语言的历史和发展 * Erlang语言的特点：函数式编程、并发编程、高性能 * Erlang语言的基本语法：变量、数据类型、操作符、控制结构 * Erlang语言的错误处理机制 OTP基础知识 ------------- OTP是Erlang语言的应用平台，旨在实现高可用性、可扩展性和高性能的系统。OTP基础知识点包括： * OTP的历史和发展 * OTP的架构组件：应用程序、服务、监控、日志 * OTP的基本概念：进程、链接、监控、事件处理 * OTP的错误处理机制 Erlang和OTP的应用 ------------------- Erlang和OTP的应用非常广泛，包括： * 电话交换系统 * 网络服务器 * 分布式系统 * 云计算 Erlang和OTP的优点 ------------------- Erlang和OTP的优点包括： * 高可用性：Erlang和OTP能够实现高可用性的系统 * 高性能：Erlang和OTP能够实现高性能的系统 * 可扩展性：Erlang和OTP能够实现可扩展性的系统 * 可靠性：Erlang和OTP能够实现可靠性的系统 Part One:Getting Past Pure Erlang; The OTP Basics ------------------------------------------------ * 第一个部分的主要内容是介绍Erlang语言和OTP的基础知识，包括Erlang语言的历史和发展、Erlang语言的特点、Erlang语言的基本语法、OTP的历史和发展、OTP的架构组件等。 Chapter One: The Foundations of Erlang/OTP ------------------------------------------ * 本章节主要介绍Erlang语言和OTP的基础知识，包括Erlang语言的历史和发展、Erlang语言的特点、OTP的历史和发展、OTP的架构组件等。 Chapter Two: Erlang Essentials ----------------------------- * 本章节主要介绍Erlang语言的基本语法，包括变量、数据类型、操作符、控制结构等。 Chapter Three: Writing a TCP-based RPC Service --------------------------------------------- * 本章节主要介绍如何使用Erlang语言编写基于TCP的RPC服务。 Chapter Four: OTP Packaging and Organization --------------------------------------------- * 本章节主要介绍OTP的打包和组织方式。 Chapter Five: Processes, Linking, and the Platform ------------------------------------------------ * 本章节主要介绍Erlang语言的进程、链接和平台相关知识。 Part Two: Building a Production System ------------------------------------------ * 第二个部分的主要内容是介绍如何使用Erlang和OTP构建生产系统，包括实现缓存系统、日志和事件处理、分布式Erlang/OTP等。 Chapter Six: Implementing a Caching System --------------------------------------------- * 本章节主要介绍如何使用Erlang和OTP实现缓存系统。 Chapter Seven: Logging and Eventing the Erlang/OTP way --------------------------------------------------- * 本章节主要介绍如何使用Erlang和OTP实现日志和事件处理。 Chapter Eight: Introducing Distributed Erlang/OTP ------------------------------------------------ * 本章节主要介绍如何使用Erlang和OTP实现分布式系统。 Chapter Nine: Converting the Cache into a Distributed Application ------------------------------------------------------------- * 本章节主要介绍如何使用Erlang和OTP将缓存系统转换为分布式应用程序。 Chapter Ten: Packaging, Services, and Deployment ------------------------------------------------- * 本章节主要介绍如何使用Erlang和OTP实现打包、服务和部署。 Part Three: Working in a Modern Environment --------------------------------------------- * 第三个部分的主要内容是介绍如何在现代环境中使用Erlang和OTP，包括非本地Erlang分布式系统等。 Chapter Eleven: Non-native Erlang Distribution --------------------------------------------- * 本章节主要介绍如何使用Erlang和OTP实现非本地分布式系统。本书涵盖了Erlang语言和OTP的基础知识、应用场景、优点等方面的内容，为读者提供了一个系统的学习指南。

©Manning Publications Co. Please post comments or corrections to the Author Online forum:

http://www.manning-sandbox.com/forum.jspa?forumID=454

Erlang Essentials

This book is not mainly about the Erlang programming language in itself, but before we

move on to programming with Erlang/OTP design patterns, we want to go through some

language basics to make sure everyone is on the same level, and also to serve as a quick

reference as you work your way through the chapters. These are the things we think every

Erlang programmer should be aware of. If you already know Erlang, you can skim this

chapter, but we’ll try to make sure there are some useful nuggets for you too.

If this is your very first contact with Erlang, we hope that the material here should be

enough for you to digest the rest of the book, but before you start using Erlang for a real

project you should also arm yourself with a more thorough guide to Erlang programming; the

chapter ends with some pointers to further reading material.

To get the most out of this chapter, you should have a working Erlang installation on your

computer. If your operating system is Windows, just open a web browser and go to

www.erlang.org/download.html, then download and run the latest version from the top

of the “Windows binary” column. For other operating systems, and further details on

installing Erlang, see Appendix A.

2.1 – The Erlang shell

An Erlang system is a more interactive environment than you may be used to. With most

programming languages, you either compile the program to an OS executable which you

then run, or you run an interpreter on a bunch of script files or byte code compiled files. In

either case, this runs until the program finishes or crashes, and then you get back to the

operating system again, and you can repeat the process (possibly after editing the code).

Erlang, on the other hand, is more like an operating system within your operating

system. Although Erlang starts pretty quickly, it is not designed for start-stop execution—it is

designed for running continuously, and for interactive development, debugging, and

upgrading. Optimally, the only reason for restarting Erlang is because of a hardware failure,

Licensed to Wow! eBook <www.wowebook.com>

©Manning Publications Co. Please post comments or corrections to the Author Online forum:

http://www.manning-sandbox.com/forum.jspa?forumID=454

operating system upgrade, or similar (but sometimes things can get complicated, and the

easiest way out may be a restart).

Interaction with an Erlang system happens mainly through the shell. The shell is your

command central; it is where you can try out short snippets to see how they work, but it is

also where you do incremental development, interactive debugging, and control a running

system in production. To make you comfortable with working in the shell, our examples are

written so that you can try them out as you read them. Let’s start a shell right away!

2.1.1 – Starting the shell

We assume that you have downloaded and installed Erlang/OTP as we said above. If you are

using Linux, Mac OS X, or any other UNIX-based system, just open a console window and

run the erl command. If you are using Windows, you should click on the Erlang icon that

the installer created for you; this runs the program called werl, which opens a special

console for Erlang that avoids the problems of running erl interactively under the normal

Windows console.

You should see something like the following:

Erlang (BEAM) emulator version 5.6.5 [smp:2] [async-threads:0]

Eshell V5.6.5 (abort with ^G)

The “

1>” is the prompt. This will change to “2>”, etc., as you enter commands. You can

use the up and down arrows or the Ctrl-P/Ctrl-N keys to move up and down among

previously entered lines, and a few other Emacs-style key bindings also exist, but most

normal keys behave as expected.

It is also possible to start the Erlang system with the –noshell flag, like this (on your

operating system command line):

erl -noshell

In this case, the Erlang system will be running, but you cannot talk to it via the console.

This is used for running Erlang as a batch job or daemon.

2.1.2 – Entering expressions

First of all, what you enter at the shell prompt isn’t “commands” as such, but expressions,

the difference being that an expression always has a result. When the expression has been

evaluated, the shell will print the result. It will also remember it so that you can refer to it

later, using the syntax v(1), v(2), etc. For example, type the number 42, followed by a

period, then press return and you should see the following:

Eshell V5.6.5 (abort with ^G)

1> 42.

Licensed to Wow! eBook <www.wowebook.com>

©Manning Publications Co. Please post comments or corrections to the Author Online forum:

http://www.manning-sandbox.com/forum.jspa?forumID=454

"hello there.\n"

Note that the result above was a string that contained a period and a newline, which is

probably not what we wanted, so we can use the up-arrow or Ctrl-P to go back and edit the

line, inserting the missing quote character in the right place this time:

2> "hello there".

"hello there"

3> v(2).

"hello there"

The shell keeps previous results so you can refer to them regardless of whether they are

numbers, strings, or any other kind of data.

2.1.3 – Shell functions

There are some functions like v(N) above that are only available in the shell, and not

anywhere else in Erlang. These shell functions usually have very short (and somewhat

cryptic) names. If you want a list of the available shell functions, just enter help() (which is

a shell function in itself). It’s a confusing list for the beginner, so here are the ones that you

should know about from start:

 help() – prints the available shell functions

 h() – prints the history of entered commands

 v(N) – fetches the value computed at prompt N

 cd(Dir) – changes current directory (Dir should be a double-quoted string)

 ls() and ls(Dir) – print a directory listing

 pwd() – print working directory (current directory)

 q() – quit (shorthand for init:stop())

 i() – print information about what the system is running

 memory() – print memory usage information

Please try out a few of these right now, for example listing or changing the current

directory, printing the history, and printing the system and memory information. Look briefly

at the output from running i() and note that much like in an operating system, there is a

whole bunch of things going on in the background apart from the shell prompt that you see.

2.1.4 – Escaping from the shell

There are some different ways of leaving the shell (and stopping the entire Erlang system).

You should be familiar with all of them, because they all have their uses in managing and

debugging a system.

Licensed to Wow! eBook <www.wowebook.com>

http://www.manning-sandbox.com/forum.jspa?forumID=454

CALLING Q() OR INIT:STOP()

The safest method is to run the shell function q(), shown in the previous section. This is a

short-cut for the function init:stop() (which you can call directly if you like), that shuts

down the Erlang system in a controlled manner, telling running applications to stop and

giving them some time to respond. This usually takes a couple of seconds, but can need

more time on a running production system with a lot to clean up.

THE BREAK MENU

If you are more impatient, and don’t have anything important running that you are afraid to

interrupt, you can bring up the low-level BREAK menu by pressing Ctrl-C on UNIX-like

systems, or Ctrl-Break on Windows in the werl console. It looks like this:

BREAK: (a)bort (c)ontinue (p)roc info (i)nfo (l)oaded

(v)ersion (k)ill (D)b-tables (d)istribution

The interesting options here are (a) to abort the system (hard shutdown), (c) to go back

to the shell, and (v) to print the running Erlang version. The others print a lot of raw

information about the system, that you may find useful for debugging once you have become

an Erlang master, and (k) even lets you browse through the current activities within Erlang

and kill off any offenders, if you really know what you are doing. Note that the shell as such

does not really know about the BREAK menu, so it will not refresh the prompt when you go

back using (c), until you press enter.

TRL-G

The third and most useful escape is the “User switch command” menu, which is reached by

pressing Ctrl-G. It will present you with this cryptic text:

User switch command

-->

Type

h or ? and press return, and you will see this list:

c [nn] - connect to job

i [nn] - interrupt job

k [nn] - kill job

j - list all jobs

s [shell] - start local shell

r [node [shell]] - start remote shell

q - quit erlang

? | h - this message

Entering

c at the “-->” prompt will get you back to the shell. Entering q will cause a

hard shutdown, like (a) in the BREAK menu—don’t confuse q here with the system-friendly

shell function q() described previously! Also note that the BREAK menu is more low-level

and can be called up while you are in the Ctrl-G menu, but not the other way around.

Licensed to Wow! eBook <www.wowebook.com>

剩余396页未读，继续阅读

xstarsky

粉丝: 1
资源: 14

Erlang/OTP实践指南：从基础到生产系统

Erlang and OTP in Action MEAP May 2010

win安装erlang/otp 25.0.3

什么是Erlang/OTP 平台

erlang/otp26.1.2下载

如何查看erlang/otp版本

erlang_otp_win64_25

erlang otp有哪些东西

erlang/otp

erlang otp是什么

erlang25.3.2

最新资源