Erlang otp что это
Erlang. Что это, зачем, как и для кого.
Статья короткая, если понравиться, попробую осветить этот язык программирования подробнее.
Erlang, это функциональный язык программирования с динамической типизацией, главной особенностью которого является программирование на уровне отдельных процессов(почти аналог threads в других ЯП), коммуникация между которыми реализуется с помощью MPI(Message Passing Interface).
Зачем
Рост частот центральных процессоров остановился. Растет количество ядер и количество узлов в кластерах. Erlang создан для максимального упрощения разработки программ которые могут использовать всю мощь многоядерных и/или много узловых систем.
Успешные примеры использования Erlanga — Jabber(ура!) сервер ejabberd, web-сервер YAWS и многочисленные эксперименты, например comet-программа(специфический стиль программирования веб-сайтов, когда сервер не разрывает подключения с клиентом, а продолжает пересылать ему данные при необходимости) способная держать 1,000,000(миллион) TCP-подключений.
Программирование на уровне отдельных, изолированных процессов дает много преимуществ перед обычным стилем программирования параллельного ПО.
Начнем из истоков — почему трудно программировать такое ПО на жаве, си или шарпе? Проблема очень глобальная и существует во всех этих языках — общий доступ к памяти. Программируя на этих ЯП вы не можете быть уверены, что вместимое памяти, куда ссылаются ваши переменные не изменил какой-то другой поток(трэд, thread, нить. ). Из-за этого, очень часто приходиться прибегать к разнообразным, проверенным временем, трюкам — локи, мутексы, семафоры. И делать это трудно. Трудно не только начинающему программисту, но и программисту с опытом, от которого зависит работоспособность системы, если над ней работают еще несколько опытных/неопытных программистов.
Вообще говоря, в Erlang’е ета проблема не решена. Она просто изолирована на уровень ниже самого языка. Каждый процесс изолирован и не имеет доступа к памяти других процессов.
В двух словах: если нет общей памяти то нет проблемы с доступом к этой памяти.
Для кого
Erlang очень прост в изучении, в синтаксисе можно разобраться в течении дня-двух, в принципах программирования — неделя-другая. Но вот парадигма программирования достаточно сложна и переключиться на нее(особенно если есть огромный опыт в императивных ЯП) достаточно сложно и иногда совсем не хочется. Не раз слышал — как можно программировать не объектами? Весь мир состоит из объектов и взаимодействия между объектами! Ответ банальный — весь мир состоит из процессов и взаимодействия между процессами в той же мере в какой он состоит из объектов.
С использованием этого ЯП многие задачи решаються тривиально, и я считаю, что Erlang — лучший ЯП, с которого стоит начинать знакомство с функциональными языками. Особенно если программы должны быть параллелизированы и кластеризированы.
Введение в Open Telecom Platform/Открытую Телекомуникационную Платформу(OTP/ОТП)
Множество людей ссылается на Erlang как «Erlang/OTP». OTP значает Открытую Телекомуникационную Платформу и представляет из себя не больше, не меньше, набор библиотек, которые поставляются вместе с Erlang. Они состоят из Erlang-интерфейсов(или поведений, behaviours англ.), которые необходимы при написании серверов, конечных автоматов, менеджеров(или диспетчеров) событий. Но это еще не все, OTP также включает интерфейс Application, который позволяет программистам запаковывать их код в одно «приложение». А Supervisor интерфейс дает программистам возможность создавать иерархическое дерево процессов, где в случае, если процесс умрет, то он будет перезапущен.
OTP — это слишком сложная вещь, чтобы рассказать о ней в одной статье, и я не буду пытаться это сделать, вместо чего я напишу серию статей в течение пары недель.
Почему мне следует узнать об Erlang/OTP?
Поэтому, изучая OTP, вы не только получаете знания и возможность создавать мощнейшие Erlang системы, но и можете сразу же присоединиться к open source проектам и получать знания и опыт там, так как они следуют той же общей структуре.
Если вы знаете общий синтаксис Erlang, то вы уже готовы начать изучать Erlang/OTP!
Интерфейсы gen_*:
Supervisor интерфейс
Процесс реализует интерфейс supervisor для описания своих дочерних процессов, которыми он будет управлять. Множество супервизоров(управляющих процессов) объединяется в иерархическое дерево супервизоров. Если дочерний процесс умирает, супервизор знает, что с ним делать, как и когда перезапускать и т.д. Таким образом ваши процессы всегда на плаву.
Чтобы получить более полное представление об интерфейсе Supervisor, прочитайте эту страницу из документации Erlang.
Application интерфейс
Чтобы узнать больше об интерфейсе Application, обратите внимание на введение из документации Erlang.
Чего ожидать в дальнейшем?
Этот пост задумывался как краткое введение в OTP. Также, чтобы ответить на такие вопросы, как «Почему я должен изучать это?». И наконец, чтобы вы знали, где и как вы можете начать. В ближайшие дни я опубликую серию статей, в которых постепенно создам OTP приложение.
Моя следующая статья, которую я покажу завтра, будет содержать введение в gen_server, где мы напишем теоретический банк-менеджер аккаунтов. К концу 2-х недель вы будете знать, как создавать ваше собстенное Erlang/OTP приложение с нуля.
Erlang otp что это
Erlang is a programming language and runtime system for building massively scalable soft real-time systems with requirements on high availability.
OTP is a set of Erlang libraries, which consists of the Erlang runtime system, a number of ready-to-use components mainly written in Erlang, and a set of design principles for Erlang programs. Learn more about Erlang and OTP.
Release notes for all OTP versions.
There are several examples on the website to help you get started. The below example defines a function world/0 that prints «Hello, world» in the Erlang shell:
Save the file as hello.erl and run erl to enter the Erlang shell to compile the module.
Learn more about the Erlang syntax of modules, functions and expressions on Erlang.org.
Erlang/OTP is available as pre-built binary packages by most OS package managers.
Compiling from source
To compile Erlang from source, run the following commands. The complete building and installation instructions can be found here.
Checkout the branch or tag of your choice
For older versions run autoconf
Configure, build and install
Alternatively, you can use Kerl, a script that lets you easily build Erlang with a few commands.
Please visit our GitHub Issues page for reporting bugs. The instructions for submitting bugs reports can be found here.
We take security bugs in Erlang/OTP seriously. Please disclose the issues regarding security by sending an email to erlang-security [at] erlang [dot] org and not by creating a public issue.
We are grateful to the community for contributing bug fixes and improvements. Read below to learn how you can take part in improving Erlang/OTP. We appreciate your help!
Read our contribution guide to learn about our development process, how to propose fixes and improvements, and how to test your changes to Erlang/OTP before submitting a pull request.
We have a list of Help Wanted bugs that we would appreciate external help from the community. This is a great place to get involved.
Erlang/OTP is released under the Apache License 2.0.
Copyright Ericsson AB 2010-2017. All Rights Reserved.
Licensed under the Apache License, Version 2.0 (the «License»); you may not use this file except in compliance with the License. You may obtain a copy of the License at
Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an «AS IS» BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License.
You can find more projects, tools and articles related to Erlang/OTP on the awesome-erlang list. Add your project there.
Знакомьтесь, Erlang
Впервые было опубликовано в журнале «Системный администратор» #8 за 2009 год
Язык программирования Erlang, первое знакомство.
В 1981 году шведская компания Ericsson запустила исследовательский проект, целью которого был поиск лучших способов программирования телекоммуникационных приложений. Основными требованиями была необходимость обеспечить быструю разработку высоконадежных приложений, работающих в течение долгого времени и поддерживающих параллельную обработку. В течение последующих 5 лет в рамках проекта было опробовано достаточно большое количество языков программирования, но не один не удовлетворял предъявляемым требованиям полностью. Было решено разрабатывать новый язык и в 1986-ом году была представлена первая версия языка программирования Erlang. До 1998-го года язык и сопутствующие библиотеки развивались внутри Ericsson, но в 1998-ом Erlang был выпущен как проект с открытым исходным кодом.
Основные особенности Erlang
Почему язык назван Erlang?
Один из авторов языка Джо Армстронг (Joe Armstrong) говорит, что есть две версии происхождения названия. По одной версии название языка расшифровывается как «Ericsson Language» (язык Ericsson). По второй — язык назван в честь датского математика Агнера Крарупа Ерланга (Agner Krarup Erlang). И кроме этого авторам нравится поддерживать такое неоднозначное толкование названия.
Что такое OTP?
На Erlang часто ссылаются как Erlang/OTP. Здесь OTP расшифровывается как Open Telecom Platform (открытая телекоммуникационная платформа) и представляет из себя набор библиотечных модулей, поставляемых с Erlang и подходы к разработке приложений. Подавляющее большинство приложений с открытым исходным кодом, использующих Erlang, таких как ejabberd, CouchDB и MochiWeb, используют OTP.
Erlang — это язык программирования общего назначения и так же среда выполнения. Хотя Erlang как язык достаточно привлекателен сам по себе, его реальная мощь проявляется при соединении со средой выполнения (виртуальной машиной) и поставляемыми с языком библиотеками. Рассмотрим основные особенности Erlang:
Проекты, в которых используется Erlang
Много коммерческих компаний используют Erlang в своих проектах, например:
Erlang так же используется и в проектах с открытым исходным кодом, например:
Начинаем работать
Перед началом изучения Erlang стоит убедиться, что он установлен в вашей операционной системе. Попробуйте набрать в командной строке команду erl:
Для Windows вызов erl из командной строки работает только, если в переменную среды PATH добавлен путь к программе. В случае стандартной установки для Windows интерпретатор команд Erlang можно запустить через меню Start > All Programs > Erlang OTP.
Если Erlang установлен в вашей системе, то вы увидите приветствие похожее на пример выше. В случае, если при вызове erl вы получили сообщение о неизвестной команде, вам нужно установить Erlang. Для большинства систем Erlang может быть установлен с использованием стандартной системы управления пакетами. Для Windows инсталлятор может быть скачан с официального сайта: http://erlang.org/download.html. В других системах можно собрать Erlang с использованием исходного кода, который так же можно скачать с официального сайта: http://erlang.org/download.html.
Командная оболочка
Командная оболочка Erlang может использоваться для интерактивных сессий и выполнения выражений языка. Запустим оболочку командой erl (или через меню Windows, как описано выше) и наберем несколько команд:
Рассмотрим нашу первую сессию подробнее:
Оболочка является достаточно мощным инструментом при работе с Erlang. Кроме ввода выражений поддерживается история команд (например, комбинации клавиш Ctrl+P и Ctrl+N используются для передвижения по введенным прежде командам), различные возможности редактирования команд и множество вспомогательных функций, которые можно посмотреть командой help(). Кроме этого, оболочка позволяет присоединяться к запущенным программам Erlang, даже на удаленных узлах (при этом так же имеется возможность автоматического использования защищенного соединения через SSH) и многое другое.
Надо заметить, что оболочка позволяет выполнять только выражения Erlang, но ее нельзя использовать для ввода других конструкций языка, которые мы будем рассматривать ниже.
Для выхода из оболочки можно использовать встроенную функцию halt():
В случае, если оболочка не отвечает (или как другой способ нормального выхода), то можно прервать выполнение нажатием клавиш Ctrl+C (или Ctrl+Break на Windows), после чего на экран будет выведено:
И теперь для прерывания выполнения можно нажать клавишу a.
Базовые понятия
После того как мы научились работать в оболочке Erlang, рассмотрим основные конструкций языка.
Числа
Как и во многих языках, арифметические выражения Erlang следуют обычным правилам для арифметических выражений, например 1 + 2 * 3 будет вычислено как 1 + (2 * 3).
Целые числа могут иметь произвольный размер и нет необходимости беспокоиться об арифметических переполнениях. Проверим это на практике:
Кроме этого целые можно вводить в различных системах счисления, используя следующую форму:
Здесь мы ввели число 10 в десятичной, шестнадцатеричной и двоичной системах.
Числа с плавающей точкой можно вводить в следующих форматах:
Для чисел с плавающей точкой Erlang использует 64-х битное представление, соответствующее стандарту IEEE 754-1985.
Переменные и сравнение с шаблоном
Имена переменных в Erlang должны начинаться с большой буквы, как в следующем примере:
В первой строке мы присваиваем значение числа 123456789 переменной X и затем значение выводится оболочкой. После этого мы выводим значение переменной и используем ее в арифметической операции.
Но при этом значение переменной Erlang может быть присвоено только один раз. Продолжая следующий пример:
Что здесь происходит? Строго говоря, оператор = в Erlang не является оператором присваивания, а является оператором сравнения с шаблоном. При этом, если переменной в текущей области видимости еще не присвоено значение, = действует как оператор присваивания, в противном случае = сравнивает значение с шаблоном.
При сравнении с шаблоном сначала вычисляется правая часть выражения, затем она сравнивается с шаблоном в левой части. В последнем примере переменная X является простейшей формой шаблона. В данном случае сравнение с шаблоном будет успешным только в случае, если значение правой части выражения равно 123456789:
Одноразовое присваивание избавляет разработчика от огромного класса ошибок связанных с неверным значением переменной, которая в противном случае могла бы быть изменена где-то между первым присваиванием и выражением, в котором она используется. Плюс к этому, такое поведение согласовывается с математической нотацией, где невозможна формула вида X = X + 1.
Атомы
В Erlang атомы используются для представления глобальных не-числовых констант. При сравнении с другими языками можно представить атомы, как элементы в перечисляемом типе данных. Значением атома является сам атом и единственная операция над атомами — это сравнение.
Атомы должны начинаться с маленькой буквы (как мы уже рассмотрели выше, переменные должны начинаться с большой буквы, так что они не пересекаются с атомами), за которой могут следовать буквы, цифры, @ и _ (точка тоже может использоваться в атомах, хотя это является не поддерживаемым разработчиками расширением языка). При использовании одинарных кавычек (‘) для атома могут использоваться практически любые символы. Примеры атомов:
Хотя Erlang не имеет отдельного булевского типа, по соглашению для этого используются атомы true и failse:
Заметьте, что во второй строке мы сравнили два атома, при сравнении которых используется лексикографический порядок. Начиная с третьей строки, мы применили встроенную функцию (Built-in function, BIF) is_boolean, которая возвращает true, или false в зависимости от типа аргумента.
Кортежи
Кортеж — это составной тип данных, который используется для хранения связанных элементов в виде единого набора. Кортежи создаются с использованием фигурных скобок и их элементы разделяются запятыми. В качестве элементов кортежа могут выступать любые типы данных Erlang, например:
По соглашению, если первый элемент кортежа атом, его называют меткой, хотя это никак не отличает такой кортеж от других кортежей. С использованием таких меток можно создавать собственные типы данных, например:
Такие метки упрощают извлечение информации из кортежа с использованием операции сравнения с шаблоном:
Здесь
Кроме этого, с использованием встроенных функций есть возможность работать с отдельными элементами кортежей, например, получать элементы по индексу (начиная с 1):
Списки
Списки как и кортежи — это составной тип данных, который может содержать любые типы данных Erlang, но в отличие от кортежей списки обрабатываются совсем другим способом и служат для хранения данных, количество которых изменяется. Списки создаются с использованием квадратных скобок, и их элементы разделяются запятыми, например:
Первый элемент списка (в нашем примере — это 1) называется вершиной списка, а оставшиеся элементы — хвостом списка. При обработке списков наиболее эффективная операция — это работа с вершиной списка, которая поддерживается в Erlang следующей конструкцией: [вершина | хвост]. Здесь вершина — это элемент, или набор элементов для добавления, или удаления из списка, а хвост — список для добавления элементов, или список после удаления вершины. Рассмотрим это на примерах:
Здесь мы создали список List, затем добавили в качестве его вершины два элемента, сформировав новый список Range. После этого мы отделили один элемент из вершины списка, сохранив его как Head.
Строки
Строго говоря, в Erlang нет отдельного типа данных для строк, строки реализованы просто как списки целых чисел. Для более удобной работы со строками их можно создавать с помощью двойных кавычек, как в этом примере:
Из следующих примеров можно увидеть, что строки и списки целых — это одно и тоже:
Здесь =:= сравнивает два элемента.
Бинарные данные
Для эффективного хранения бинарных данных рекомендуется использовать бинарный тип данных. Бинарный тип данных состоит из набора целых в диапазоне от 0 до 255 (или соответствующих символов) и представляется с помощью двух угловых скобок:
Заключение
В этой статье были кратко рассмотрены основные особенности и базовые понятия языка программирования Erlang. Более детальная информация по языку может быть найдена в документации, находящейся на официальном сайте и других сайтах, описывающих Erlang. Вот некоторые из полезных сайтов:
В следующей статье будет рассмотрено последовательное программирование в Erlang
Глава 16. Введение в OTP
OTP содержит ряд мощных инструментов, таких как, полноценный web сервер, FTP сервер, CORBA ORB и других, написанных на Erlang. Еще OTP содержит высокотехнологичные инструменты для создания приложений в сфере телекоммуникаций, с реализацией протоколов H.248, SNMP, и кросс-компилятор ASN.1-to-Erlang. Но я не буду говорить об этом; вы сможете найти информацию по этой теме, посетив сайты, ссылки на которые даны в разделе С.1 Онлайн документации, на странице __.
Если вы хотите разработать свою программу, используя OTP, тогда основные принципы в поведении OTP будут для вас очень привлекательны. Это поведение объединяет общие поведенческие модели – думайте об этом, как об основе которая, по сути, есть параметризованные вызовы модулей. Мощь OTP исходит из ее свойств, таких как отказоустойчивость, масштабируемость, динамический изменяемый код и т.д. собственно это и есть поведение OTP. Другими словами, при написании обратных вызовов вам не надо беспокоиться об отказоустойчивости, потому что об этом позаботится сама OTP. Java-программисты могут думать о поведении как о J2EE контейнере.
Проще говоря, поведение решает нефункциональную часть проблемы, а обратные вызовы – функциональную. Прелесть в том, что нефункциональная часть проблемы (например, динамическое изменение кода) всегда одинакова для всех приложений, тогда как функциональная часть (реализация обратных вызовов) различна в каждом отдельном случае.
Вот план этой главы:
16.1 Путь к обыкновенному серверу (Generic Server)
Это наиболее важный подраздел в этой книге, прочитайте его один раз, два раза, прочитайте его 100 раз – чтобы убедиться в том, что вы все поняли.
Мы приступаем к написанию четырех маленьких северов с названиями server1, server2. каждый слегка будет отличаться от предыдущего. Нашей целью является полное разделение нефункциональной и функциональной частей решаемой задачи. Последнее предложение сейчас скорее всего ничего для вас не значит, но не беспокойтесь – скоро об всем узнаете. Итак, глубоко вдохните.
Сервер №1: Простой сервер
Первая попытка. Это маленький сервер, который мы реализуем, написав модуль обратных вызовов.
Это небольшое количество кода является основой для сервера. Давайте напишем обратные вызовы для сервера №1. Вот код модуля обратных вызовов:
Этот код фактически выполняет две задачи. Он выступает в роли модуля обратных вызовов, вызываемых из серверного кода, и иногда содержит интерфейсные конструкции, которые будут вызываться на стороне клиента. Обычно, по соглашениям OTP, эти функции объединяются в один модуль.
Чтобы увидеть как это работает, сделайте следующее:
Сейчас прервемся и подумаем. Обратный вызов не имеет кода для параллелизации, не порождает процессы, не отправляет и не принимает сообщения, ничего не регистрирует. Это просто последовательный код и ничего более. Что же это значит?
А это означает то, что мы сможем написать клиент-серверное приложение без понимания того, что лежит в основе модели параллельных процессов.
Это основной шаблон для всех серверов. Однажды вы поймете основные структуры, это просто как «цигарка».
Сервер №2: Сервер с транзакциями
В этом примере сервер прервет клиента, если результатом запроса будет ошибка:
Зачем хранить оригинальное состояние? Обработчик выполняется с ошибкой тогда, когда клиент отправляет неверное сообщение, в ответ клиент получает сообщение об аварии. Клиент не может работать, потому что запрос, отправленный на сервер, привел к сбою в обработчике. Зато другие клиенты желающие использовать этот сервер не пострадают. Более того,состояние сервера не изменится, если в обработчике возникнет ошибка.
Замечу, что модуль обратных вызовов для этого сервера точно такой же как и для сервера №1. Изменяя сервер и оставляя неизменным модуль обратных вызовов, мы может менять нефункциональную часть поведения модуля обратных вызовов.
Сервер №3: Сервер с горячей заменой кода
Сейчас мы добавим в наш сервер механизм горячей замены кода:
Как же это работает?
Сначала мы запустим server3 с модулем обратных вызовов name_server1 :
Теперь, я полагаю, мы захотим найти все имена которые обслуживает наш сервер имен. Но в нашем API нет функции для выполнения такой задачи – модуль name_server имеет лишь функции для добавления и поиска имен.
Быстро запускаем наш текстовый редактор и пишем наш новый модуль обратных вызовов:
Сейчас мы скомпилируем этот код и скажем серверу заменить работающий модуль обратных вызовов новым:
И можем запустить новые функции это сервера:
Сейчас прервемся и снова подумаем. Последние две задачи, которые мы с вами решили, в целом, считаются сложными, но на самом деле это очень сложные задачи. Серверы с механизмом транзакций сложны в написании; серверы с динамической заменой кода еще более сложны в написании.
Сервер №4: Транзакции и горячая замена кода
В предыдущих двух серверах семантика горячей замены и семантика транзакций были разделены. Давайте объединим обе возможности в одном сервере. Итак, держите ваши шляпы.
Этот сервер предоставляет обе возможности, и горячую замену кода и транзакции. Замечательно.
Сервер №5: Еще больше кайфа
Теперь, получив знания о динамической замене кода, мы можем кайфануть по полной программе. Сейчас мы рассмотрим сервер, который ничего не делает, пока мы ему не скажем, изменить поведение:
Теперь давайте создадим функциональность сервера. Ничего сложного придумывать не будем, просто посчитаем факториал:
Эрланг в PlanetLab
Несколько лет назад, когда мои исследования только начинались, я работал в PlanetLab. Я имел доступ к сети PlanetLab(*) и установил «пустые» Эрланг серверы на все компьютеры (около 450-ти машин). Я не знал что я буду делать с этими машинами, просто установил серверную инфраструктуру для использования в каких-нибудь целях в будущем.
Так как я запустил серверы, я мог легко сказать, пустым серверам превратиться в серверы, выполняющие реальную работу.
Обычная практика (для начала) – это запустить web-серверы, и установить плагины на web-серверы. Мой подход – отступить на один шаг назад и установить пустые серверы. Потом уже устанавливать плагины web-серверов для превращения пустых серверов в web-серверы. Ведь когда web-сервер станет не нужен, мы можем заставить серверы выполнять что-нибудь еще.
(*) Сеть, широко используемая учеными для тестирования новых сетевых сервисов или модификации уже существующих http://www.planet-lab.org/.
Теперь, когда наш сервер стал факториал-сервером, мы сделаем вызов:
Наш процесс будет факториал-сервером до тех пор, пока мы не скажем ему стать кем-нибудь другим, отправив ему сообщение
Как вы увидели в предыдущем примере, мы может иметь широкий диапазон различных типов серверов, с различной семантикой и совершенно удивительными свойствами. Эта технология почти такая же мощная. Используя весь ее потенциал, можно создавать очень маленькие программы удивительной мощности и красоте. Когда мы делали проекты промышленных масштабов с десятками и сотнями программистов, мы не хотели делать некоторые вещи слишком динамичными. Мы хотели добиться баланса между обобщенностью и мощностью и получали нечто подходящее для коммерческих продуктов. Получали код, который меняется от версии к версии, и который превосходно работает, но очень сложен в отладке, если вдруг что-то пойдет не так. Если мы делали много динамических изменений в нашем коде, и это переставало работать, найти причину было очень нелегко.
Примеры серверов в этом разделе не совсем корректны. Они писались, чтобы показать идеи, но они содержат одну или две чрезвычайно маленьких и тонких ошибки. Я не буде прямо сейчас рассказывать о них, я дам некоторые комментарии по этому поводу в конце главы.
Эрланговый модуль gen_server – это что-то вроде логического завершения последовательности достаточно простых серверов (точно таких же которые мы писали на протяжении всей главы).
Он используется в промышленных продуктах, начиная с 1998 года. Сотни серверов могут быть частью одного продукта. Эти серверы будут написаны программистами с использованием обычного последовательного кода. Все ошибки обрабатываются, и все нефункциональное поведение учтено в типовой части сервера.
16.2 Начнем с gen_server
На самом деле это очень просто. Не думайте – просто следуйте плану!
Шаг 1: Выбрать имя для модуля обратных вызовов
Шаг 2: Написать интерфейсные конструкции
Мы определим пять интерфейсных конструкций, все они будут в модуле my_bank :
start() — Открыть банк.
stop() — Закрыть банк.
new_account(Who) — Создать новый аккаунт.
deposit(Who, Amount) — Положить деньги в банк.
withdraw(Who, Amount) — Взять деньги, если есть на счету.
gen_server:call(?MODULE, Term) используется для вызова удаленных процедур сервера.
Шаг 3: Написать конструкции модуля обратных вызовов
Этот пример содержит простой скелет, который нужно заполнить, чтобы получить сервер. Ключевое слово –behaviour используется компилятором, чтобы знать какие предупреждения и сообщения об ошибках генерировать.
Итак, шаблон вставлен, и мы просто отредактируем его куски. Мы имеем все аргументы в интерфейсных конструкциях, согласно аргументам шаблона.
Значение Reply отправляется обратно клиенту, как результат вызова удаленной процедуры.
State это просто переменная, представляющая глобальное состояние сервера, оно было передано серверу. В нашем банковском сервере состояние не меняется; это просто индекс ETS таблицы и он постоянный (хотя содержимое таблицы меняется).
После редактирования кусков кода в шаблоне, мы получили следующий код:
Теперь все готово. Давайте посетим наш банк:
16.3 Структура обратных вызовов gen_server
Что же происходит, когда мы запускаем сервер?
Ниже приведен шаблон для init :
Что же происходит, когда мы обращаемся к серверу?
handle_call/3 имеет следующий шаблон:
Вызовы и Образы
Соответствующий обратный вызов handle_cast показан в шаблоне ниже:
Спонтанные сообщения
Шаблон для handle_info выглядит так:
Прощай, малышка
Замена кода
Вы можете динамически изменять состояние своего сервера, пока он запущен. Вызов этой функции обратного вызова производит подсистема «управления релизами» когда система выполняет обновление программного кода.
16.4 Код и Шаблоны
Этот код сделан в emacs: