Overview

• module Async
  • module Container
    • class Channel

      Provides a basic multi-thread/multi-process uni-directional communication channel.
    • class Controller

      Manages the life-cycle of one or more containers in order to support a persistent system.
    • class Error

      Represents an error that occured during container execution.
    • class Terminate

      Similar to Interrupt = ::Interrupt, but represents SIGTERM.
    • class Kill

      Similar to class Async::Container::Terminate, but represents SIGKILL.
    • class Restart

      Similar to Interrupt = ::Interrupt, but represents SIGHUP.
    • class SetupError

      Represents the error which occured when a container failed to start up correctly.
    • class Forked

      A multi-process container which uses Process.fork.

      • class Child

        Represents a running child process from the point of view of the parent container.

        • class Instance

          Represents a running child process from the point of view of the child process.
    • class Generic

      A base class for implementing containers.
    • class Group

      Manages a group of running processes.
    • class Hybrid

      Provides a hybrid multi-process multi-thread container.
    • class Keyed

      Tracks a key/value pair such that unmarked keys can be identified and cleaned up.
    • module Notify

      Handles the details of several process readiness protocols.

      • class Client

        Represents a client that can send messages to the parent controller in order to notify it of readiness, status changes, etc.
      • class Console

        Implements a general process readiness protocol with output to the local console.
      • class Log

        Represents a client that uses a local log file to communicate readiness, status changes, etc.
      • class Pipe

        Implements a process readiness protocol using an inherited pipe file descriptor.
      • class Server

        A simple UDP server that can be used to receive messages from a child process, tracking readiness, status changes, etc.

        • class Context

          A bound context for receiving messages.
      • class Socket

        Implements the systemd NOTIFY_SOCKET process readiness protocol.
    • class Policy

      A policy for managing container behavior and responding to child process lifecycle events.
    • class Statistics

      Tracks various statistics relating to child instances in a container.

      • class Rate

        Tracks rate information over a sliding time window using a circular buffer.
    • class Threaded

      A multi-thread container which uses Thread.fork.

      • class Child

        Represents a running child thread from the point of view of the parent container.

        • class Exit

          Used to propagate the exit status of a child process invoked by Async::Container::Threaded::Child::Instance#exec.
        • class Instance

          Represents a running child thread from the point of view of the child thread.
        • class Status

          A pseudo exit-status wrapper.
• Provider