ed-precompiled_puma 7.0.4

data/lib/puma/runner.rb

@@ -0,0 +1,211 @@
+# 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
+
+    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
+
+    # 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
+    end
+
+    def development?
+      @options[:environment] == "development"
+    end
+
+    def test?
+      @options[:environment] == "test"
+    end
+
+    def log(str)
+      @log_writer.log str
+    end
+
+    # @version 5.0.0
+    def stop_control
+      @control&.stop true
+    end
+
+    def error(str)
+      @log_writer.error str
+    end
+
+    def debug(str)
+      @log_writer.log "- #{str}" if @options[:debug]
+    end
+
+    def start_control
+      str = @options[:control_url]
+      return unless str
+
+      require_relative 'app/status'
+
+      if token = @options[:control_auth_token]
+        token = nil if token.empty? || token == 'none'
+      end
+
+      app = Puma::App::Status.new @launcher, token
+
+      # 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 }
+
+      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 thread_name: 'ctl'
+      @control = control
+    end
+
+    # @version 5.0.0
+    def close_control_listeners
+      @control.binder.close_listeners if @control
+    end
+
+    def output_header(mode)
+      min_t = @options[:min_threads]
+      max_t = @options[:max_threads]
+      environment = @options[:environment]
+
+      log "Puma starting in #{mode} mode..."
+      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
+
+    def warn_ruby_mn_threads
+      return if !ENV.key?('RUBY_MN_THREADS')
+
+      log "! WARNING: Detected `RUBY_MN_THREADS=#{ENV['RUBY_MN_THREADS']}`"
+      log "! This setting is known to cause performance regressions with Puma."
+      log "! Consider disabling this environment variable: https://github.com/puma/puma/issues/3720"
+    end
+
+    def redirected_io?
+      @options[:redirect_stdout] || @options[:redirect_stderr]
+    end
+
+    def redirect_io
+      stdout = @options[:redirect_stdout]
+      stderr = @options[:redirect_stderr]
+      append = @options[:redirect_append]
+
+      if stdout
+        ensure_output_directory_exists(stdout, 'STDOUT')
+
+        STDOUT.reopen stdout, (append ? "a" : "w")
+        STDOUT.puts "=== puma startup: #{Time.now} ==="
+        STDOUT.flush unless STDOUT.sync
+      end
+
+      if stderr
+        ensure_output_directory_exists(stderr, 'STDERR')
+
+        STDERR.reopen stderr, (append ? "a" : "w")
+        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 @config.app_configured?
+        error "No application configured, nothing to run"
+        exit 1
+      end
+
+      begin
+        @app = @config.app
+      rescue Exception => e
+        log "! Unable to load application: #{e.class}: #{e.message}"
+        raise e
+      end
+
+      @launcher.binder.parse @options[:binds]
+    end
+
+    # @!attribute [r] app
+    def app
+      @app ||= @config.app
+    end
+
+    def start_server
+      server = Puma::Server.new(app, @events, @options)
+      server.inherit_binder(@launcher.binder)
+      server
+    end
+
+    private
+    def ensure_output_directory_exists(path, io_name)
+      unless Dir.exist?(File.dirname(path))
+        raise "Cannot redirect #{io_name} to #{path}"
+      end
+    end
+
+    def utc_iso8601(val)
+      "#{val.utc.strftime '%FT%T'}Z"
+    end
+
+    def stats
+      {
+        versions: {
+          puma: Puma::Const::PUMA_VERSION,
+          ruby: {
+            engine: RUBY_ENGINE,
+            version: RUBY_VERSION,
+            patchlevel: RUBY_PATCHLEVEL
+          }
+        }
+      }
+    end
+
+    # 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