puma 6.4.3 → 8.0.2

data/lib/puma/cluster_accept_loop_delay.rb

@@ -0,0 +1,91 @@
+# frozen_string_literal: true
+
+module Puma
+  # Calculate a delay value for sleeping when running in clustered mode
+  #
+  # The main reason this is a class is so it can be unit tested independently.
+  # This makes modification easier in the future if we can encode properties of the
+  # delay into a test instead of relying on end-to-end testing only.
+  #
+  # This is an imprecise mechanism to address specific goals:
+  #
+  # - Evenly distribute requests across all workers at start
+  # - Evenly distribute CPU resources across all workers
+  #
+  # ## Goal: Distribute requests across workers at start
+  #
+  # There was a perf bug in Puma where one worker would wake up slightly before the rest and accept
+  # all the requests on the socket even though it didn't have enough resources to process all of them.
+  # This was originally fixed by never calling accept when a worker had more requests than threads
+  # already https://github.com/puma/puma/pull/3678/files/2736ebddb3fc8528e5150b5913fba251c37a8bf7#diff-a95f46e7ce116caddc9b9a9aa81004246d5210d5da5f4df90a818c780630166bL251-L291
+  #
+  # With the introduction of true keepalive support, there are two ways a request can come in:
+  # - A new request from a new client comes into the socket and it must be "accept"-ed
+  # - A keepalive request is served and the connection is retained. Another request is then accepted
+  #
+  # Ideally the server handles requests in the order they come in, and ideally it doesn't accept more requests than it can handle.
+  # These goals are contradictory, because when the server is at maximum capacity due to keepalive connections, it could mean we
+  # block all new requests, even if those came in before the new request on the older keepalive connection.
+  #
+  # ## Goal: Distribute CPU resources across all workers
+  #
+  # - This issue was opened https://github.com/puma/puma/issues/2078
+  #
+  # There are several entangled issues and it's not exactly clear what the root cause is, but the observable outcome
+  # was that performance was better with a small sleep, and that eventually became the default.
+  #
+  # An attempt to describe why this works is here: https://github.com/puma/puma/issues/2078#issuecomment-3287032470.
+  #
+  # Summarizing: The delay is for tuning the rate at which "accept" is called on the socket.
+  # Puma works by calling "accept" nonblock on the socket in a loop. When there are multiple workers
+  # (processes), they will "race" to accept a request at roughly the same rate. However, if one
+  # worker has all threads busy processing requests, then accepting a new request might "steal" it from
+  # a less busy worker. If a worker has no work to do, it should loop as fast as possible.
+  #
+  # ## Solution: Distribute requests across workers at start
+  #
+  # For now, both goals are framed as "load balancing" across workers (processes) and achieved through
+  # the same mechanism of sleeping longer to delay busier workers. Rather than the prior Puma 6.x
+  # and earlier behavior of using a binary on/off sleep value, we increase it an amount proportional
+  # to the load the server is under, capping the maximum delay to the scenario where all threads are busy
+  # and the todo list has reached a multiplier of the maximum number of threads.
+  #
+  # Private: API may change unexpectedly
+  class ClusterAcceptLoopDelay
+    attr_reader :max_delay
+
+    # Initialize happens once, `call` happens often. Perform global calculations here.
+    def initialize(
+      # Number of workers in the cluster
+      workers: ,
+      # Maximum delay in seconds i.e. 0.005 is 5 milliseconds
+      max_delay:
+    )
+      @on = max_delay > 0 && workers >= 2
+      @max_delay = max_delay.to_f
+
+      # Reach maximum delay when `max_threads * overload_multiplier` is reached in the system
+      @overload_multiplier = 25.0
+    end
+
+    def on?
+      @on
+    end
+
+    # We want the extreme values of this delay to be known (minimum and maximum) as well as
+    # a predictable curve between the two. i.e. no step functions or hard cliffs.
+    #
+    # Return value is always numeric. Returns 0 if there should be no delay.
+    def calculate(
+      # Number of threads working right now, plus number of requests in the todo list
+      busy_threads_plus_todo:,
+      # Maximum number of threads in the pool, note that the busy threads (alone) may go over this value at times
+      # if the pool needs to be reaped. The busy thread plus todo count may go over this value by a large amount.
+      max_threads:
+    )
+      max_value = @overload_multiplier * max_threads
+      # Approaches max delay when `busy_threads_plus_todo` approaches `max_value`
+      return max_delay * busy_threads_plus_todo.clamp(0, max_value) / max_value
+    end
+  end
+end

data/lib/puma/commonlogger.rb

@@ -29,13 +29,13 @@ module Puma
 
     CONTENT_LENGTH       = 'Content-Length' # should be lower case from app,
                                             # Util::HeaderHash allows mixed
-    HTTP_VERSION         = Const::HTTP_VERSION
     HTTP_X_FORWARDED_FOR = Const::HTTP_X_FORWARDED_FOR
     PATH_INFO            = Const::PATH_INFO
     QUERY_STRING         = Const::QUERY_STRING
     REMOTE_ADDR          = Const::REMOTE_ADDR
     REMOTE_USER          = 'REMOTE_USER'
     REQUEST_METHOD       = Const::REQUEST_METHOD
+    SERVER_PROTOCOL      = Const::SERVER_PROTOCOL
 
     def initialize(app, logger=nil)
       @app = app
@@ -70,7 +70,7 @@ module Puma
         env[REQUEST_METHOD],
         env[PATH_INFO],
         env[QUERY_STRING].empty? ? "" : "?#{env[QUERY_STRING]}",
-        env[HTTP_VERSION],
+        env[SERVER_PROTOCOL],
         now - began_at ]
 
       write(msg)
@@ -87,7 +87,7 @@ module Puma
         env[REQUEST_METHOD],
         env[PATH_INFO],
         env[QUERY_STRING].empty? ? "" : "?#{env[QUERY_STRING]}",
-        env[HTTP_VERSION],
+        env[SERVER_PROTOCOL],
         status.to_s[0..3],
         length,
         now - began_at ]

data/lib/puma/configuration.rb

@@ -1,9 +1,12 @@
 # frozen_string_literal: true
 
-require_relative 'rack/builder'
+require 'socket'
+require 'uri'
+
 require_relative 'plugin'
 require_relative 'const'
 require_relative 'dsl'
+require_relative 'events'
 
 module Puma
   # A class used for storing "leveled" configuration options.
@@ -113,7 +116,7 @@ module Puma
   #     config = Configuration.new({}) do |user_config, file_config, default_config|
   #       user_config.port 3003
   #     end
-  #     config.load
+  #     config.clamp
   #     puts config.options[:port]
   #     # => 3003
   #
@@ -126,42 +129,48 @@ module Puma
   # is done because an environment variable may have been modified while loading
   # configuration files.
   class Configuration
+    class NotLoadedError < StandardError; end
+    class NotClampedError < StandardError; end
+
     DEFAULTS = {
       auto_trim_time: 30,
-      binds: ['tcp://0.0.0.0:9292'.freeze],
-      clean_thread_locals: false,
+      binds: ['tcp://[::]:9292'.freeze],
       debug: false,
       early_hints: nil,
+      enable_keep_alives: true,
       environment: 'development'.freeze,
+      fiber_per_request: !!ENV.fetch("PUMA_FIBER_PER_REQUEST", false),
       # Number of seconds to wait until we get the first data for the request.
       first_data_timeout: 30,
+      force_shutdown_after: -1,
+      http_content_length_limit: nil,
       # Number of seconds to wait until the next request before shutting down.
       idle_timeout: nil,
       io_selector_backend: :auto,
       log_requests: false,
       logger: STDOUT,
-      # How many requests to attempt inline before sending a client back to
-      # the reactor to be subject to normal ordering. The idea here is that
-      # we amortize the cost of going back to the reactor for a well behaved
-      # but very "greedy" client across 10 requests. This prevents a not
-      # well behaved client from monopolizing the thread forever.
-      max_fast_inline: 10,
+      # Limits how many requests a keep alive connection can make.
+      # The connection will be closed after it reaches `max_keep_alive`
+      # requests.
+      max_io_threads: 0,
+      max_keep_alive: 999,
       max_threads: Puma.mri? ? 5 : 16,
       min_threads: 0,
       mode: :http,
       mutate_stdout_and_stderr_to_sync_on_write: true,
       out_of_band: [],
       # Number of seconds for another request within a persistent session.
-      persistent_timeout: 20,
+      persistent_timeout: 65, # PUMA_PERSISTENT_TIMEOUT
+      prune_bundler: false,
       queue_requests: true,
       rackup: 'config.ru'.freeze,
       raise_exception_on_sigterm: true,
       reaping_time: 1,
       remote_address: :socket,
-      silence_single_worker_warning: false,
       silence_fork_callback_warning: false,
+      silence_single_worker_warning: false,
       tag: File.basename(Dir.getwd),
-      tcp_host: '0.0.0.0'.freeze,
+      tcp_host: '::'.freeze,
       tcp_port: 9292,
       wait_for_less_busy_worker: 0.005,
       worker_boot_timeout: 60,
@@ -170,28 +179,36 @@ module Puma
       worker_shutdown_timeout: 30,
       worker_timeout: 60,
       workers: 0,
-      http_content_length_limit: nil
     }
 
-    def initialize(user_options={}, default_options = {}, &block)
-      default_options = self.puma_default_options.merge(default_options)
+    def initialize(user_options={}, default_options = {}, env = ENV, &block)
+      default_options = self.puma_default_options(env).merge(events: Events.new).merge(default_options)
 
-      @options     = UserFileDefaultOptions.new(user_options, default_options)
+      @_options    = UserFileDefaultOptions.new(user_options, default_options)
       @plugins     = PluginLoader.new
-      @user_dsl    = DSL.new(@options.user_options, self)
-      @file_dsl    = DSL.new(@options.file_options, self)
-      @default_dsl = DSL.new(@options.default_options, self)
+      @events      = @_options[:events] || Events.new
+      @hooks       = {}
+      @user_dsl    = DSL.new(@_options.user_options, self)
+      @file_dsl    = DSL.new(@_options.file_options, self)
+      @default_dsl = DSL.new(@_options.default_options, self)
 
-      if !@options[:prune_bundler]
-        default_options[:preload_app] = (@options[:workers] > 1) && Puma.forkable?
-      end
+      @puma_bundler_pruned = env.key? 'PUMA_BUNDLER_PRUNED'
 
       if block
         configure(&block)
       end
+
+      @loaded = false
+      @clamped = false
     end
 
-    attr_reader :options, :plugins
+    attr_reader :plugins, :events, :hooks, :_options
+
+    def options
+      raise NotClampedError, "ensure clamp is called before accessing options" unless @clamped
+
+      @_options
+    end
 
     def configure
       yield @user_dsl, @file_dsl, @default_dsl
@@ -204,7 +221,7 @@ module Puma
     def initialize_copy(other)
       @conf        = nil
       @cli_options = nil
-      @options     = @options.dup
+      @_options     = @_options.dup
     end
 
     def flatten
@@ -212,42 +229,49 @@ module Puma
     end
 
     def flatten!
-      @options = @options.flatten
+      @_options = @_options.flatten
       self
     end
 
-    def puma_default_options
+    def puma_default_options(env = ENV)
       defaults = DEFAULTS.dup
-      puma_options_from_env.each { |k,v| defaults[k] = v if v }
+      defaults[:tcp_host] = self.class.default_tcp_host
+      defaults[:binds] = [self.class.default_tcp_bind]
+      puma_options_from_env(env).each { |k,v| defaults[k] = v if v }
       defaults
     end
 
-    def puma_options_from_env
-      min = ENV['PUMA_MIN_THREADS'] || ENV['MIN_THREADS']
-      max = ENV['PUMA_MAX_THREADS'] || ENV['MAX_THREADS']
-      workers = ENV['WEB_CONCURRENCY']
+    def puma_options_from_env(env = ENV)
+      min = env['PUMA_MIN_THREADS'] || env['MIN_THREADS']
+      max = env['PUMA_MAX_THREADS'] || env['MAX_THREADS']
+      persistent_timeout = env['PUMA_PERSISTENT_TIMEOUT']
+      workers_env = env['WEB_CONCURRENCY']
+      workers = workers_env && workers_env.strip != "" ? parse_workers(workers_env.strip) : nil
 
       {
-        min_threads: min && Integer(min),
-        max_threads: max && Integer(max),
-        workers: workers && Integer(workers),
-        environment: ENV['APP_ENV'] || ENV['RACK_ENV'] || ENV['RAILS_ENV'],
+        min_threads: min && min != "" && Integer(min),
+        max_threads: max && max != "" && Integer(max),
+        persistent_timeout: persistent_timeout && persistent_timeout != "" && Integer(persistent_timeout),
+        workers: workers,
+        environment: env['APP_ENV'] || env['RACK_ENV'] || env['RAILS_ENV'],
       }
     end
 
     def load
+      @loaded = true
       config_files.each { |config_file| @file_dsl._load_from(config_file) }
-
-      @options
+      @_options
     end
 
     def config_files
-      files = @options.all_of(:config_files)
+      raise NotLoadedError, "ensure load is called before accessing config_files" unless @loaded
+
+      files = @_options.all_of(:config_files)
 
       return [] if files == ['-']
       return files if files.any?
 
-      first_default_file = %W(config/puma/#{@options[:environment]}.rb config/puma.rb).find do |f|
+      first_default_file = %W(config/puma/#{@_options[:environment]}.rb config/puma.rb).find do |f|
         File.exist?(f)
       end
 
@@ -255,9 +279,18 @@ module Puma
     end
 
     # Call once all configuration (included from rackup files)
-    # is loaded to flesh out any defaults
+    # is loaded to finalize defaults and lock in the configuration.
+    #
+    # This also calls load if it hasn't been called yet.
     def clamp
-      @options.finalize_values
+      load unless @loaded
+      run_mode_hooks
+      set_conditional_default_options
+      @_options.finalize_values
+      rewrite_unavailable_ipv6_binds!
+      @clamped = true
+      warn_hooks
+      options
     end
 
     # Injects the Configuration object into the env
@@ -276,11 +309,11 @@ module Puma
     # Indicate if there is a properly configured app
     #
     def app_configured?
-      @options[:app] || File.exist?(rackup)
+      options[:app] || File.exist?(rackup)
     end
 
     def rackup
-      @options[:rackup]
+      options[:rackup]
     end
 
     # Load the specified rackup file, pull options from
@@ -289,9 +322,9 @@ module Puma
     def app
       found = options[:app] || load_rackup
 
-      if @options[:log_requests]
+      if options[:log_requests]
         require_relative 'commonlogger'
-        logger = @options[:logger]
+        logger = options[:custom_logger] ? options[:custom_logger] : options[:logger]
         found = CommonLogger.new(found, logger)
       end
 
@@ -300,7 +333,7 @@ module Puma
 
     # Return which environment we're running in
     def environment
-      @options[:environment]
+      options[:environment]
     end
 
     def load_plugin(name)
@@ -308,16 +341,19 @@ module Puma
     end
 
     # @param key [:Symbol] hook to run
-    # @param arg [Launcher, Int] `:on_restart` passes Launcher
+    # @param arg [Launcher, Int] `:before_restart` passes Launcher
     #
     def run_hooks(key, arg, log_writer, hook_data = nil)
-      @options.all_of(key).each do |b|
+      log_writer.debug { "Running #{key} hooks" }
+
+      options.all_of(key).each do |hook_options|
         begin
-          if Array === b
-            hook_data[b[1]] ||= Hash.new
-            b[0].call arg, hook_data[b[1]]
+          block = hook_options[:block]
+          if id = hook_options[:id]
+            hook_data[id] ||= Hash.new
+            block.call arg, hook_data[id]
           else
-            b.call arg
+            block.call arg
           end
         rescue => e
           log_writer.log "WARNING hook #{key} failed with exception (#{e.class}) #{e.message}"
@@ -327,7 +363,24 @@ module Puma
     end
 
     def final_options
-      @options.final_options
+      options.final_options
+    end
+
+    def self.default_tcp_host
+      ipv6_interface_available? ? Const::UNSPECIFIED_IPV6 : Const::UNSPECIFIED_IPV4
+    end
+
+    def self.default_tcp_bind(port = DEFAULTS[:tcp_port])
+      URI::Generic.build(scheme: 'tcp', host: default_tcp_host, port: Integer(port)).to_s
+    end
+
+    def self.ipv6_interface_available?
+      Socket.getifaddrs.any? do |ifaddr|
+        addr = ifaddr.addr
+        addr&.ipv6? && !addr&.ipv6_loopback?
+      end
+    rescue StandardError
+      false
     end
 
     def self.temp_path
@@ -337,14 +390,66 @@ module Puma
       "#{Dir.tmpdir}/puma-status-#{t}-#{$$}"
     end
 
+    def self.random_token
+      require 'securerandom' unless defined?(SecureRandom)
+
+      SecureRandom.hex(16)
+    end
+
     private
 
+    def rewrite_unavailable_ipv6_binds!
+      return if self.class.ipv6_interface_available?
+
+      tried_ipv6_bind = false
+      bind_schemes = ['tcp', 'ssl']
+
+      @_options[:binds] = Array(@_options[:binds]).map do |bind|
+        uri = URI.parse(bind)
+        next bind unless bind_schemes.include?(uri.scheme)
+
+        host = uri.host&.delete_prefix('[')&.delete_suffix(']')
+        next bind unless host&.include?(':')
+
+        tried_ipv6_bind = true
+        next bind unless host == Const::UNSPECIFIED_IPV6
+
+        uri.host = Const::UNSPECIFIED_IPV4
+        uri.to_s
+      rescue URI::InvalidURIError
+        bind
+      end
+
+      warn "WARNING: IPv6 bind requested but no non-loopback IPv6 interface was detected" if tried_ipv6_bind
+    end
+
+    def require_processor_counter
+      require 'concurrent/utility/processor_counter'
+    rescue LoadError
+      warn <<~MESSAGE
+        WEB_CONCURRENCY=auto or workers(:auto) requires the "concurrent-ruby" gem to be installed.
+        Please add "concurrent-ruby" to your Gemfile.
+      MESSAGE
+      raise
+    end
+
+    def parse_workers(value)
+      if value == :auto || value == 'auto'
+        require_processor_counter
+        Integer(::Concurrent.available_processor_count)
+      else
+        Integer(value)
+      end
+    rescue ArgumentError, TypeError
+      raise ArgumentError, "workers must be an Integer or :auto"
+    end
+
     # Load and use the normal Rack builder if we can, otherwise
     # fallback to our minimal version.
     def rack_builder
       # Load bundler now if we can so that we can pickup rack from
       # a Gemfile
-      if ENV.key? 'PUMA_BUNDLER_PRUNED'
+      if @puma_bundler_pruned
         begin
           require 'bundler/setup'
         rescue LoadError
@@ -354,11 +459,10 @@ module Puma
       begin
         require 'rack'
         require 'rack/builder'
+        ::Rack::Builder
       rescue LoadError
-        # ok, use builtin version
-        return Puma::Rack::Builder
-      else
-        return ::Rack::Builder
+        require_relative 'rack/builder'
+        Puma::Rack::Builder
       end
     end
 
@@ -368,22 +472,51 @@ module Puma
       rack_app, rack_options = rack_builder.parse_file(rackup)
       rack_options = rack_options || {}
 
-      @options.file_options.merge!(rack_options)
+      options.file_options.merge!(rack_options)
 
       config_ru_binds = []
       rack_options.each do |k, v|
         config_ru_binds << v if k.to_s.start_with?("bind")
       end
 
-      @options.file_options[:binds] = config_ru_binds unless config_ru_binds.empty?
+      options.file_options[:binds] = config_ru_binds unless config_ru_binds.empty?
 
       rack_app
     end
 
-    def self.random_token
-      require 'securerandom' unless defined?(SecureRandom)
+    def run_mode_hooks
+      workers_before = @_options[:workers]
+      key = workers_before > 0 ? :cluster : :single
 
-      SecureRandom.hex(16)
+      @_options.all_of(key).each(&:call)
+
+      unless @_options[:workers] == workers_before
+        raise "cannot change the number of workers inside a #{key} configuration hook"
+      end
+    end
+
+    def set_conditional_default_options
+      @_options.default_options[:preload_app] = !@_options[:prune_bundler] &&
+        (@_options[:workers] > 1) && Puma.forkable?
+    end
+
+    def warn_hooks
+      return if options[:workers] > 0
+      return if options[:silence_fork_callback_warning]
+
+      log_writer = LogWriter.stdio
+      @hooks.each_key do |hook|
+        options.all_of(hook).each do |hook_options|
+          next unless hook_options[:cluster_only]
+
+          log_writer.log(<<~MSG.tr("\n", " "))
+            Warning: The code in the `#{hook}` block will not execute
+            in the current Puma configuration. The `#{hook}` block only
+            executes in Puma's cluster mode. To fix this, either remove the
+            `#{hook}` call or increase Puma's worker count above zero.
+          MSG
+        end
+      end
     end
   end
 end

data/lib/puma/const.rb

@@ -100,13 +100,11 @@ module Puma
   # too taxing on performance.
   module Const
 
-    PUMA_VERSION = VERSION = "6.4.3"
-    CODE_NAME = "The Eagle of Durango"
+    PUMA_VERSION = VERSION = "8.0.2"
+    CODE_NAME = "Into the Arena"
 
     PUMA_SERVER_STRING = ["puma", PUMA_VERSION, CODE_NAME].join(" ").freeze
 
-    FAST_TRACK_KA_TIMEOUT = 0.2
-
     # How long to wait when getting some write blocking on the socket when
     # sending data back
     WRITE_TIMEOUT = 10
@@ -125,9 +123,9 @@ module Puma
       # Indicate that we couldn't parse the request
       400 => "HTTP/1.1 400 Bad Request\r\n\r\n",
       # The standard empty 404 response for bad requests.  Use Error4040Handler for custom stuff.
-      404 => "HTTP/1.1 404 Not Found\r\nConnection: close\r\n\r\n",
+      404 => "HTTP/1.1 404 Not Found\r\nconnection: close\r\n\r\n",
       # The standard empty 408 response for requests that timed out.
-      408 => "HTTP/1.1 408 Request Timeout\r\nConnection: close\r\n\r\n",
+      408 => "HTTP/1.1 408 Request Timeout\r\nconnection: close\r\n\r\n",
       # Indicate that there was an internal error, obviously.
       500 => "HTTP/1.1 500 Internal Server Error\r\n\r\n",
       # Incorrect or invalid header value
@@ -137,7 +135,7 @@ module Puma
     }.freeze
 
     # The basic max request size we'll try to read.
-    CHUNK_SIZE = 16 * 1024
+    CHUNK_SIZE = 64 * 1024
 
     # This is the maximum header that is allowed before a client is booted.  The parser detects
     # this, but we'd also like to do this as well.
@@ -230,6 +228,7 @@ module Puma
     RACK_INPUT = "rack.input"
     RACK_URL_SCHEME = "rack.url_scheme"
     RACK_AFTER_REPLY = "rack.after_reply"
+    RACK_RESPONSE_FINISHED = "rack.response_finished"
     PUMA_SOCKET = "puma.socket"
     PUMA_CONFIG = "puma.config"
     PUMA_PEERCERT = "puma.peercert"
@@ -252,14 +251,14 @@ module Puma
     KEEP_ALIVE = "keep-alive"
 
     CONTENT_LENGTH2 = "content-length"
-    CONTENT_LENGTH_S = "Content-Length: "
+    CONTENT_LENGTH_S = "content-length: "
     TRANSFER_ENCODING = "transfer-encoding"
     TRANSFER_ENCODING2 = "HTTP_TRANSFER_ENCODING"
 
-    CONNECTION_CLOSE = "Connection: close\r\n"
-    CONNECTION_KEEP_ALIVE = "Connection: Keep-Alive\r\n"
+    CONNECTION_CLOSE = "connection: close\r\n"
+    CONNECTION_KEEP_ALIVE = "connection: keep-alive\r\n"
 
-    TRANSFER_ENCODING_CHUNKED = "Transfer-Encoding: chunked\r\n"
+    TRANSFER_ENCODING_CHUNKED = "transfer-encoding: chunked\r\n"
     CLOSE_CHUNKED = "0\r\n\r\n"
 
     CHUNKED = "chunked"
@@ -292,6 +291,18 @@ module Puma
     # Banned keys of response header
     BANNED_HEADER_KEY = /\A(rack\.|status\z)/.freeze
 
-    PROXY_PROTOCOL_V1_REGEX = /^PROXY (?:TCP4|TCP6|UNKNOWN) ([^\r]+)\r\n/.freeze
+    PROXY_PROTOCOL_V1_REGEX = /\APROXY (?:TCP4|TCP6|UNKNOWN) ([^\r]+)\r\n/.freeze
+    PROXY_PROTOCOL_V1_MAX_LENGTH = 107
+
+    # All constants are prefixed with `PIPE_` to avoid name collisions.
+    module PipeRequest
+      PIPE_WAKEUP = "!"
+      PIPE_BOOT = "b"
+      PIPE_FORK = "f"
+      PIPE_EXTERNAL_TERM = "e"
+      PIPE_TERM = "t"
+      PIPE_PING = "p"
+      PIPE_IDLE = "i"
+    end
   end
 end