Designing for Scalability with Erlang/OTP. Implement Robust, Fault-Tolerant Systems

Spis treści książki

• 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 Youll 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
  • Whats 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
  • Whats 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
  • Whats 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
  • Whats 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
    • Lets Test It
  • Whats 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
  • Whats 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
  • Whats 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
  • Whats 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
  • Whats 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
  • Whats 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
  • Whats 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
  • Whats 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
  • Whats 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
  • Whats Next?
• 16. Monitoring and Preemptive Support
  • Monitoring
    • Logs
    • Metrics
    • Alarms
  • Preemptive Support
  • Summing Up
  • Whats Next?
• Index

pokaż cały spis treści

ukryj recenzje