puma 3.11.1 → 6.6.0

data/lib/puma/runner.rb

@@ -1,77 +1,103 @@
-require 'puma/server'
-require 'puma/const'
+# frozen_string_literal: true
+
+require_relative 'server'
+require_relative 'const'
 
 module Puma
+  # Generic class that is used by `Puma::Cluster` and `Puma::Single` to
+  # serve requests. This class spawns a new instance of `Puma::Server` via
+  # a call to `start_server`.
   class Runner
-    def initialize(cli, events)
-      @launcher = cli
-      @events = events
-      @options = cli.options
+
+    include ::Puma::Const::PipeRequest
+
+    def initialize(launcher)
+      @launcher = launcher
+      @log_writer = launcher.log_writer
+      @events = launcher.events
+      @config = launcher.config
+      @options = launcher.options
       @app = nil
       @control = nil
+      @started_at = Time.now
+      @wakeup = nil
     end
 
-    def daemon?
-      @options[:daemon]
+    # Returns the hash of configuration options.
+    # @return [Puma::UserFileDefaultOptions]
+    attr_reader :options
+
+    def wakeup!
+      return unless @wakeup
+
+      @wakeup.write PIPE_WAKEUP unless @wakeup.closed?
+
+    rescue SystemCallError, IOError
+      Puma::Util.purge_interrupt_queue
     end
 
     def development?
       @options[:environment] == "development"
     end
 
+    def test?
+      @options[:environment] == "test"
+    end
+
     def log(str)
-      @events.log str
+      @log_writer.log str
     end
 
-    def before_restart
-      @control.stop(true) if @control
+    # @version 5.0.0
+    def stop_control
+      @control&.stop true
     end
 
     def error(str)
-      @events.error str
+      @log_writer.error str
     end
 
     def debug(str)
-      @events.log "- #{str}" if @options[:debug]
+      @log_writer.log "- #{str}" if @options[:debug]
     end
 
     def start_control
       str = @options[:control_url]
       return unless str
 
-      require 'puma/app/status'
-
-      uri = URI.parse str
-
-      app = Puma::App::Status.new @launcher
+      require_relative 'app/status'
 
       if token = @options[:control_auth_token]
-        app.auth_token = token unless token.empty? or token == :none
+        token = nil if token.empty? || token == 'none'
       end
 
-      control = Puma::Server.new app, @launcher.events
-      control.min_threads = 0
-      control.max_threads = 1
+      app = Puma::App::Status.new @launcher, token
 
-      case uri.scheme
-      when "tcp"
-        log "* Starting control server on #{str}"
-        control.add_tcp_listener uri.host, uri.port
-      when "unix"
-        log "* Starting control server on #{str}"
-        path = "#{uri.host}#{uri.path}"
-        mask = @options[:control_url_umask]
+      # A Reactor is not created and nio4r is not loaded when 'queue_requests: false'
+      # Use `nil` for events, no hooks in control server
+      control = Puma::Server.new app, nil,
+        { min_threads: 0, max_threads: 1, queue_requests: false, log_writer: @log_writer }
 
-        control.add_unix_listener path, mask
-      else
-        error "Invalid control URI: #{str}"
+      begin
+        control.binder.parse [str], nil, 'Starting control server'
+      rescue Errno::EADDRINUSE, Errno::EACCES => e
+        raise e, "Error: Control server address '#{str}' is already in use. Original error: #{e.message}"
       end
 
-      control.run
+      control.run thread_name: 'ctl'
       @control = control
     end
 
+    # @version 5.0.0
+    def close_control_listeners
+      @control.binder.close_listeners if @control
+    end
+
+    # @!attribute [r] ruby_engine
+    # @deprecated Use `RUBY_DESCRIPTION` instead
     def ruby_engine
+      warn "Puma::Runner#ruby_engine is deprecated; use RUBY_DESCRIPTION instead. It will be removed in puma v7."
+
       if !defined?(RUBY_ENGINE) || RUBY_ENGINE == "ruby"
         "ruby #{RUBY_VERSION}-p#{RUBY_PATCHLEVEL}"
       else
@@ -86,14 +112,19 @@ module Puma
     def output_header(mode)
       min_t = @options[:min_threads]
       max_t = @options[:max_threads]
+      environment = @options[:environment]
 
       log "Puma starting in #{mode} mode..."
-      log "* Version #{Puma::Const::PUMA_VERSION} (#{ruby_engine}), codename: #{Puma::Const::CODE_NAME}"
-      log "* Min threads: #{min_t}, max threads: #{max_t}"
-      log "* Environment: #{ENV['RACK_ENV']}"
-
-      if @options[:mode] == :tcp
-        log "* Mode: Lopez Express (tcp)"
+      log "* Puma version: #{Puma::Const::PUMA_VERSION} (\"#{Puma::Const::CODE_NAME}\")"
+      log "* Ruby version: #{RUBY_DESCRIPTION}"
+      log "*  Min threads: #{min_t}"
+      log "*  Max threads: #{max_t}"
+      log "*  Environment: #{environment}"
+
+      if mode == "cluster"
+        log "*   Master PID: #{Process.pid}"
+      else
+        log "*          PID: #{Process.pid}"
       end
     end
 
@@ -107,69 +138,83 @@ module Puma
       append = @options[:redirect_append]
 
       if stdout
-        unless Dir.exist?(File.dirname(stdout))
-          raise "Cannot redirect STDOUT to #{stdout}"
-        end
+        ensure_output_directory_exists(stdout, 'STDOUT')
 
         STDOUT.reopen stdout, (append ? "a" : "w")
-        STDOUT.sync = true
         STDOUT.puts "=== puma startup: #{Time.now} ==="
+        STDOUT.flush unless STDOUT.sync
       end
 
       if stderr
-        unless Dir.exist?(File.dirname(stderr))
-          raise "Cannot redirect STDERR to #{stderr}"
-        end
+        ensure_output_directory_exists(stderr, 'STDERR')
 
         STDERR.reopen stderr, (append ? "a" : "w")
-        STDERR.sync = true
         STDERR.puts "=== puma startup: #{Time.now} ==="
+        STDERR.flush unless STDERR.sync
+      end
+
+      if @options[:mutate_stdout_and_stderr_to_sync_on_write]
+        STDOUT.sync = true
+        STDERR.sync = true
       end
     end
 
     def load_and_bind
-      unless @launcher.config.app_configured?
+      unless @config.app_configured?
         error "No application configured, nothing to run"
         exit 1
       end
 
-      # Load the app before we daemonize.
       begin
-        @app = @launcher.config.app
+        @app = @config.app
       rescue Exception => e
         log "! Unable to load application: #{e.class}: #{e.message}"
         raise e
       end
 
-      @launcher.binder.parse @options[:binds], self
+      @launcher.binder.parse @options[:binds]
     end
 
+    # @!attribute [r] app
     def app
-      @app ||= @launcher.config.app
+      @app ||= @config.app
     end
 
     def start_server
-      min_t = @options[:min_threads]
-      max_t = @options[:max_threads]
-
-      server = Puma::Server.new app, @launcher.events, @options
-      server.min_threads = min_t
-      server.max_threads = max_t
-      server.inherit_binder @launcher.binder
+      server = Puma::Server.new(app, @events, @options)
+      server.inherit_binder(@launcher.binder)
+      server
+    end
 
-      if @options[:mode] == :tcp
-        server.tcp_mode!
+    private
+    def ensure_output_directory_exists(path, io_name)
+      unless Dir.exist?(File.dirname(path))
+        raise "Cannot redirect #{io_name} to #{path}"
       end
+    end
 
-      if @options[:early_hints]
-        server.early_hints = true
-      end
+    def utc_iso8601(val)
+      "#{val.utc.strftime '%FT%T'}Z"
+    end
 
-      unless development?
-        server.leak_stack_on_error = false
-      end
+    def stats
+      {
+        versions: {
+          puma: Puma::Const::PUMA_VERSION,
+          ruby: {
+            engine: RUBY_ENGINE,
+            version: RUBY_VERSION,
+            patchlevel: RUBY_PATCHLEVEL
+          }
+        }
+      }
+    end
 
-      server
+    # this method call should always be guarded by `@log_writer.debug?`
+    def debug_loaded_extensions(str)
+      @log_writer.debug "────────────────────────────────── #{str}"
+      re_ext = /\.#{RbConfig::CONFIG['DLEXT']}\z/i
+      $LOADED_FEATURES.grep(re_ext).each { |f| @log_writer.debug("    #{f}") }
     end
   end
 end

data/lib/puma/sd_notify.rb

@@ -0,0 +1,146 @@
+# frozen_string_literal: true
+
+require "socket"
+
+module Puma
+  # The MIT License
+  #
+  # Copyright (c) 2017-2022 Agis Anastasopoulos
+  #
+  # Permission is hereby granted, free of charge, to any person obtaining a copy of
+  # this software and associated documentation files (the "Software"), to deal in
+  # the Software without restriction, including without limitation the rights to
+  # use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
+  # the Software, and to permit persons to whom the Software is furnished to do so,
+  # subject to the following conditions:
+  #
+  # The above copyright notice and this permission notice shall be included in all
+  # copies or substantial portions of the Software.
+  #
+  # THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+  # IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
+  # FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
+  # COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
+  # IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+  # CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+  #
+  # This is a copy of https://github.com/agis/ruby-sdnotify as of commit cca575c
+  # The only changes made was "rehoming" it within the Puma module to avoid
+  # namespace collisions and applying standard's code formatting style.
+  #
+  # SdNotify is a pure-Ruby implementation of sd_notify(3). It can be used to
+  # notify systemd about state changes. Methods of this package are no-op on
+  # non-systemd systems (eg. Darwin).
+  #
+  # The API maps closely to the original implementation of sd_notify(3),
+  # therefore be sure to check the official man pages prior to using SdNotify.
+  #
+  # @see https://www.freedesktop.org/software/systemd/man/sd_notify.html
+  module SdNotify
+    # Exception raised when there's an error writing to the notification socket
+    class NotifyError < RuntimeError; end
+
+    READY     = "READY=1"
+    RELOADING = "RELOADING=1"
+    STOPPING  = "STOPPING=1"
+    STATUS    = "STATUS="
+    ERRNO     = "ERRNO="
+    MAINPID   = "MAINPID="
+    WATCHDOG  = "WATCHDOG=1"
+    FDSTORE   = "FDSTORE=1"
+
+    def self.ready(unset_env=false)
+      notify(READY, unset_env)
+    end
+
+    def self.reloading(unset_env=false)
+      notify(RELOADING, unset_env)
+    end
+
+    def self.stopping(unset_env=false)
+      notify(STOPPING, unset_env)
+    end
+
+    # @param status [String] a custom status string that describes the current
+    #   state of the service
+    def self.status(status, unset_env=false)
+      notify("#{STATUS}#{status}", unset_env)
+    end
+
+    # @param errno [Integer]
+    def self.errno(errno, unset_env=false)
+      notify("#{ERRNO}#{errno}", unset_env)
+    end
+
+    # @param pid [Integer]
+    def self.mainpid(pid, unset_env=false)
+      notify("#{MAINPID}#{pid}", unset_env)
+    end
+
+    def self.watchdog(unset_env=false)
+      notify(WATCHDOG, unset_env)
+    end
+
+    def self.fdstore(unset_env=false)
+      notify(FDSTORE, unset_env)
+    end
+
+    # @param [Boolean] true if the service manager expects watchdog keep-alive
+    #   notification messages to be sent from this process.
+    #
+    # If the $WATCHDOG_USEC environment variable is set,
+    # and the $WATCHDOG_PID variable is unset or set to the PID of the current
+    # process
+    #
+    # @note Unlike sd_watchdog_enabled(3), this method does not mutate the
+    #   environment.
+    def self.watchdog?
+      wd_usec = ENV["WATCHDOG_USEC"]
+      wd_pid = ENV["WATCHDOG_PID"]
+
+      return false if !wd_usec
+
+      begin
+        wd_usec = Integer(wd_usec)
+      rescue
+        return false
+      end
+
+      return false if wd_usec <= 0
+      return true if !wd_pid || wd_pid == $$.to_s
+
+      false
+    end
+
+    # Notify systemd with the provided state, via the notification socket, if
+    # any.
+    #
+    # Generally this method will be used indirectly through the other methods
+    # of the library.
+    #
+    # @param state [String]
+    # @param unset_env [Boolean]
+    #
+    # @return [Fixnum, nil] the number of bytes written to the notification
+    #   socket or nil if there was no socket to report to (eg. the program wasn't
+    #   started by systemd)
+    #
+    # @raise [NotifyError] if there was an error communicating with the systemd
+    #   socket
+    #
+    # @see https://www.freedesktop.org/software/systemd/man/sd_notify.html
+    def self.notify(state, unset_env=false)
+      sock = ENV["NOTIFY_SOCKET"]
+
+      return nil if !sock
+
+      ENV.delete("NOTIFY_SOCKET") if unset_env
+
+      begin
+        Addrinfo.unix(sock, :DGRAM).connect { |s| s.write state }
+      rescue StandardError => e
+        raise NotifyError, "#{e.class}: #{e.message}", e.backtrace
+      end
+    end
+  end
+end