Home Page Icon
Home Page
Table of Contents for
Cover
Close
Cover
by Steve Vinoski, Francesco Cesarini
Designing for Scalability with Erlang/OTP
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
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
Generic FSMs
A Behavior Example
Starting the FSM
Sending 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
Dynamic Children
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
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
Creating a Release Package
Start Scripts and Configuring on the Target
Arguments and Flags
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
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
Sharing Data
Tradeoffs Between Consistency and Availability
Summing Up
What’s Next?
15. Scaling Out
Horizontal and Vertical Scaling
Capacity Planning
Capacity Testing
Balancing Your System
Finding Bottlenecks
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
Search in book...
Toggle Font Controls
Playlists
Add To
Create new playlist
Name your new playlist
Playlist description (optional)
Cancel
Create playlist
Sign In
Email address
Password
Forgot Password?
Create account
Login
or
Continue with Facebook
Continue with Google
Sign Up
Full Name
Email address
Confirm Email Address
Password
Login
Create account
or
Continue with Facebook
Continue with Google
Next
Next Chapter
Designing for Scalability with Erlang/OTP
Add Highlight
No Comment
..................Content has been hidden....................
You can't read the all page of ebook, please click
here
login for view all page.
Day Mode
Cloud Mode
Night Mode
Reset