An Erlang Implementation of Multiparty Session Actors

Abstract

By requiring co-ordination to take place using explicit message passing instead of relying on shared memory, actor-based programming languages have been shown to be effective tools for building reliable and fault-tolerant distributed systems. Although naturally communication-centric, communication patterns in actor-based applications remain informally specified, meaning that errors in communication are detected late, if at all. Multiparty session types are a formalism to describe, at a global level, the interactions between multiple communicating entities. This article describes the implementation of a prototype framework for monitoring Erlang/OTP gen_server applications against multiparty session types, showing how previous work on multiparty session actors can be adapted to a purely actor-based language, and how monitor violations and termination of session participants can be reported in line with the Erlang mantra of "let it fail". Finally, the framework is used to implement two case studies: an adaptation of a freely-available DNS server, and a chat server.Comment: In Proceedings ICE 2016, arXiv:1608.0313

Let it recover: multiparty protocol-induced recovery

“…The work [16] presents a design and an implementation of a runtime verification for Erlang where interactions are checked against Scribble specifications. The framework allows a session to continue when a failed role is not involved in the remainder of the session.…”

Benefits of session types for software development

“…Programming with session types can be understood and used efficiently by real world programmers. All papers extending various programming languages [17,3,11,9,13,16] assume that this is the case. However, session types add another layer of complexity to programming.…”

“…They have proved popular, finding their way into various programming languages and tools. As of late there has been an emphasis on implementations, be that in existing languages: C [17], Erlang [3], Go [16], Java [11,9], to name just a few, or in new languages: Scribble, Links [13], SILL. The session type community certainly believes it to be worthwhile to add session types to as many languages as possible.…”

Explicit Connection Actions in Multiparty Session Types

“…It relies on a special-purpose run-time locking mechanism to block dynamically joining participants until some safe entry point, hindering its use in existing applications. Implementations of sessions in Python [15] and Erlang [19] have used a notion of subsession [14] as a coarse-grained mechanism for dynamically introducing participants. The idea is to launch a separate child session, by the heavyweight atomic multiparty initiation, involving a subset of the current participants along with other new participants; unlike this paper, where additional roles enter the same, running session by the connect and accept actions between the two relevant participants.…”

“…Much research, both multiparty and the special case of binary sessions, has focused on addressing (b) in various ways: extending existing languages to support static session typing (e.g., Links [32]) via pre-processing tools (Java [25,45]), embedding into existing languages via encodings (Haskell [40,26], Rust [27]), dynamic session typing by runtime monitoring (Python [15], Erlang [19]), hybrid (part static, part dynamic) approaches (Java [24], Scala [42], ML [36]), and code generation (MPI/C [35]). …”