Designing for Scalability With Erlang/OTP · Implement Robust, Fault-Tolerant Systems by Cesarini, Francesco -- Read -- Imperial Library of Trantor

Index

Preface

Francesco: Why This Book? Steve: Why This Book? Who Should Read This Book How To Read This Book Acknowledgments Conventions Used in This Book Using Code Examples Safari® Books Online How to Contact Us

1. Introduction

Defining the Problem OTP

Erlang Tools and Libraries System Design Principles Erlang Nodes

Distribution, Infrastructure, and Multicore Summing Up What You’ll Learn in This Book

2. Introducing Erlang

Recursion and Pattern Matching Functional Influence

Fun with Anonymous Functions List Comprehensions: Generate and Test

Processes and Message Passing Fail Safe! Links and Monitors for Supervision

Links Monitors

Records Maps Macros Upgrading Modules ETS: Erlang Term Storage Distributed Erlang

Naming and Communication Node Connections and Visibility

Summing Up What’s Next?

3. Behaviors

Process Skeletons Design Patterns

Callback Modules

Extracting Generic Behaviors

Starting the Server The Client Functions The Server Loop Functions Internal to the Server

The Generic Server Message Passing: Under the Hood Summing Up What’s Next?

4. Generic Servers

Generic Servers Behavior Directives Starting a Server Message Passing

Synchronous Message Passing Asynchronous Message Passing Other Messages Unhandled Messages Synchronizing Clients

Termination Call Timeouts

Deadlocks

Generic Server Timeouts

Hibernating Behaviors

Going Global Linking Behaviors Summing Up What’s Next?

5. Controlling OTP Behaviors

The sys Module

Tracing and Logging System Messages Your Own Trace Functions Statistics, Status, and State The sys Module Recap

Spawn Options

Memory Management and Garbage Collection

Process heap Virtual binary heap Full sweep of the heap

Spawn Options to Avoid Timeouts

Summing Up What’s Next?

6. Finite State Machines

Finite State Machines the Erlang Way Coffee FSM

The Hardware Stub The Erlang Coffee Machine

Starting The events The selection state The payment state The remove state

Generic FSMs A Behavior Example

Starting the FSM Sending Events

Asynchronous events Defining states Timeouts Asynchronous events to all states Synchronous events

Termination

Summing Up Get Your Hands Dirty

The Phone Controllers Let’s Test It

What’s Next?

7. Event Handlers

Events Generic Event Managers and Handlers

Starting and Stopping Event Managers Adding Event Handlers Deleting an Event Handler Sending Synchronous and Asynchronous Events Retrieving Data Handling Errors and Invalid Return Values Swapping Event Handlers Wrapping It All Up

The SASL Alarm Handler Summing Up What’s Next?

8. Supervisors

Supervision Trees OTP Supervisors

The Supervisor Behavior Starting the Supervisor The Supervisor Specification

The restart specification The child specification

Dynamic Children

Simple one for one Gluing it all together

Non-OTP-Compliant Processes

Supervisor bridges Adding non-OTP-compliant processes

Scalability and Short-Lived Processes Synchronous Starts for Determinism Testing Your Supervision Strategy

How Does This Compare? Summing Up What’s Next?

9. Applications

How Applications Run The Application Structure The Callback Module

Starting and Stopping Applications

Application Resource Files

The Base Station Controller Application File

Starting an Application Environment Variables Application Types and Termination Strategies Distributed Applications Start Phases Included Applications

Start Phases in Included Applications

Combining Supervisors and Applications The SASL Application

Progress Reports Error Reports Crash Reports Supervisor Reports

Summing Up What’s Next?

10. Special Processes and Your Own Behaviors

Special Processes

The Mutex Starting Special Processes

Basic template for starting a special process Asynchronously starting a special process

The Mutex States Handling Exits System Messages Trace and Log Events Putting It Together Dynamic Modules and Hibernating

Your Own Behaviors

Rules for Creating Behaviors An Example Handling TCP Streams

Summing Up What’s Next?

11. System Principles and Release Handling

System Principles

Release Directory Structure Release Resource Files Creating a Release Creating the Boot File

Script files The make_script parameters

Creating a Release Package Start Scripts and Configuring on the Target Arguments and Flags

Heart The Erlang loader

The init Module

Rebar3

Generating a Rebar3 Release Project Creating a Release with Rebar3 Rebar3 Releases with Project Dependencies

Wrapping Up What’s Next?

12. Release Upgrades

Software Upgrades

The First Version of the Coffee FSM Adding a State

Creating a Release Upgrade

The Code to Upgrade Application Upgrade Files High-Level Instructions Release Upgrade Files Low-Level Instructions Installing an Upgrade The Release Handler Upgrading Environment Variables

Upgrading Special Processes Upgrading in Distributed Environments Upgrading the Emulator and Core Applications Upgrades with Rebar3 Summing Up What’s Next?

13. Distributed Architectures

Node Types and Families Networking

Distributed Erlang

Riak Core Scalable Distributed Erlang

Sockets and SSL Service Orientation and Microservices Peer to Peer

Interfaces Summing Up What’s Next?

14. Systems That Never Stop

Availability

Fault Tolerance Resilience Reliability

At most once, exactly once, and at least once

Sharing Data

Share nothing Share something Share everything

Tradeoffs Between Consistency and Availability

Summing Up What’s Next?

15. Scaling Out

Horizontal and Vertical Scaling Capacity Planning

Capacity Testing

Generating load

Balancing Your System Finding Bottlenecks

Synchronous versus asynchronous calls

System Blueprints

Load Regulation and Backpressure Summing Up What’s Next?

16. Monitoring and Preemptive Support

Monitoring

Logs Metrics Alarms

Preemptive Support Summing Up What’s Next?

Index

← Prev
Back
Next →

← Prev
Back
Next →