puma 2.2.0 → 8.0.2

data/lib/puma/control_cli.rb

@@ -1,49 +1,92 @@
+# frozen_string_literal: true
+
 require 'optparse'
-require 'puma/const'
-require 'puma/configuration'
-require 'yaml'
+require_relative 'const'
+require_relative 'detect'
 require 'uri'
 require 'socket'
+
 module Puma
   class ControlCLI
 
-    COMMANDS = %w{halt restart start stats status stop}
-
-    def is_windows?
-      RUBY_PLATFORM =~ /(win|w)32$/ ? true : false
-    end
-
-    def initialize(argv, stdout=STDOUT, stderr=STDERR)
-      @argv = argv
+    # values must be string or nil
+    # value of `nil` means command cannot be processed via signal
+    # @version 5.0.3
+    CMD_PATH_SIG_MAP = {
+      'gc'       => nil,
+      'gc-stats' => nil,
+      'halt'              => 'SIGQUIT',
+      'info'              => Puma.backtrace_signal,
+      'phased-restart'    => 'SIGUSR1',
+      'refork'            => 'SIGURG',
+      'reload-worker-directory' => nil,
+      'reopen-log'        => 'SIGHUP',
+      'restart'           => 'SIGUSR2',
+      'start'    => nil,
+      'stats'    => nil,
+      'status'   => '',
+      'stop'              => 'SIGTERM',
+      'thread-backtraces' => nil,
+      'worker-count-down' => 'SIGTTOU',
+      'worker-count-up'   => 'SIGTTIN'
+    }.freeze
+
+    # commands that cannot be used in a request
+    NO_REQ_COMMANDS = %w[info reopen-log worker-count-down worker-count-up].freeze
+
+    # @version 5.0.0
+    PRINTABLE_COMMANDS = %w[gc-stats stats thread-backtraces].freeze
+
+    def initialize(argv, stdout=STDOUT, stderr=STDERR, env: ENV)
+      @state = nil
+      @quiet = false
+      @pidfile = nil
+      @pid = nil
+      @control_url = nil
+      @control_auth_token = nil
+      @config_file = nil
+      @command = nil
+      @environment = env['APP_ENV'] || env['RACK_ENV'] || env['RAILS_ENV']
+
+      @argv = argv.dup
       @stdout = stdout
       @stderr = stderr
-      @options = {}
-      
+      @cli_options = {}
+
       opts = OptionParser.new do |o|
-        o.banner = "Usage: pumactl (-p PID | -P pidfile | -S status_file | -C url -T token) (#{COMMANDS.join("|")})"
+        o.banner = "Usage: pumactl (-p PID | -P pidfile | -S status_file | -C url -T token | -F config.rb) (#{CMD_PATH_SIG_MAP.keys.join("|")})"
 
         o.on "-S", "--state PATH", "Where the state file to use is" do |arg|
-          @options[:status_path] = arg
+          @state = arg
         end
 
-        o.on "-Q", "--quiet", "Not display messages" do |arg|
-          @options[:quiet_flag] = true
+        o.on "-Q", "--quiet", "Do not display messages" do |arg|
+          @quiet = true
         end
 
         o.on "-P", "--pidfile PATH", "Pid file" do |arg|
-          @options[:pid_file] = arg
+          @pidfile = arg
         end
 
         o.on "-p", "--pid PID", "Pid" do |arg|
-          @options[:pid] = arg.to_i
+          @pid = arg.to_i
         end
 
         o.on "-C", "--control-url URL", "The bind url to use for the control server" do |arg|
-          @options[:control_url] = arg
+          @control_url = arg
         end
 
         o.on "-T", "--control-token TOKEN", "The token to use as authentication for the control server" do |arg|
-          @options[:control_auth_token] = arg
+          @control_auth_token = arg
+        end
+
+        o.on "-F", "--config-file PATH", "Puma config script" do |arg|
+          @config_file = arg
+        end
+
+        o.on "-e", "--environment ENVIRONMENT",
+          "The environment to run the Rack app on (default development)" do |arg|
+          @environment = arg
         end
 
         o.on_tail("-H", "--help", "Show this message") do
@@ -52,94 +95,119 @@ module Puma
         end
 
         o.on_tail("-V", "--version", "Show version") do
-          puts Const::PUMA_VERSION
+          @stdout.puts Const::PUMA_VERSION
           exit
         end
       end
 
       opts.order!(argv) { |a| opts.terminate a }
-      
-      command = argv.shift
-      @options[:command] = command if command
+      opts.parse!
 
-      # check present of command
-      unless @options[:command]
-        raise "Available commands: #{COMMANDS.join(", ")}"
+      @command = argv.shift
+
+      # check presence of command
+      unless @command
+        raise "Available commands: #{CMD_PATH_SIG_MAP.keys.join(", ")}"
       end
 
-      unless COMMANDS.include? @options[:command]
-        raise "Invalid command: #{@options[:command]}" 
+      unless CMD_PATH_SIG_MAP.key? @command
+        raise "Invalid command: #{@command}"
       end
 
+      unless @config_file == '-'
+        environment = @environment || 'development'
+
+        if @config_file.nil?
+          @config_file = %W(config/puma/#{environment}.rb config/puma.rb).find do |f|
+            File.exist?(f)
+          end
+        end
+
+        if @config_file
+          # needed because neither `Puma::CLI` or `Puma::Server` are loaded
+          require_relative '../puma'
+
+          require_relative 'configuration'
+          require_relative 'log_writer'
+
+          config = Puma::Configuration.new({ config_files: [@config_file] }, {} , env)
+          config.clamp
+
+          @state              ||= config.options[:state]
+          @control_url        ||= config.options[:control_url]
+          @control_auth_token ||= config.options[:control_auth_token]
+          @pidfile            ||= config.options[:pidfile]
+        end
+      end
     rescue => e
       @stdout.puts e.message
       exit 1
     end
-    
+
     def message(msg)
-      @stdout.puts msg unless @options[:quiet_flag]
+      @stdout.puts msg unless @quiet
     end
 
     def prepare_configuration
-      if @options.has_key? :status_path
-        unless File.exist? @options[:status_path]
-          raise "Status file not found: #{@options[:status_path]}"
+      if @state
+        unless File.exist? @state
+          raise "State file not found: #{@state}"
         end
 
-        status = YAML.load File.read(@options[:status_path])
+        require_relative 'state_file'
 
-        if status.has_key? "config"
+        sf = Puma::StateFile.new
+        sf.load @state
 
-          conf = status["config"]
-
-          # get control_url
-          if url = conf.options[:control_url]
-            @options[:control_url] = url
-          end
-
-          # get control_auth_token
-          if token = conf.options[:control_auth_token]
-            @options[:control_auth_token] = token
-          end
-
-          # get pid
-          @options[:pid] = status["pid"].to_i
-        else
-          raise "Invalid status file: #{@options[:status_path]}"
-        end
-
-      elsif @options.has_key? :pid_file
+        @control_url = sf.control_url
+        @control_auth_token = sf.control_auth_token
+        @pid = sf.pid
+      elsif @pidfile
         # get pid from pid_file
-        @options[:pid] = File.open(@options[:pid_file]).gets.to_i
+        @pid = File.read(@pidfile, mode: 'rb:UTF-8').to_i
       end
     end
 
     def send_request
-      uri = URI.parse @options[:control_url]
-      
+      uri = URI.parse @control_url
+
+      host = uri.host
+
       # create server object by scheme
-      @server = case uri.scheme
-                when "tcp"
-                  TCPSocket.new uri.host, uri.port
-                when "unix"
-                  UNIXSocket.new "#{uri.host}#{uri.path}"
-                else
-                  raise "Invalid scheme: #{uri.scheme}"
-                end
-
-      if @options[:command] == "status"
-        message "Puma is started"
+      server =
+        case uri.scheme
+        when 'ssl'
+          require 'openssl'
+          host = host[1..-2] if host&.start_with? '['
+          OpenSSL::SSL::SSLSocket.new(
+            TCPSocket.new(host, uri.port),
+            OpenSSL::SSL::SSLContext.new)
+            .tap { |ssl| ssl.sync_close = true }  # default is false
+            .tap(&:connect)
+        when 'tcp'
+          host = host[1..-2] if host&.start_with? '['
+          TCPSocket.new host, uri.port
+        when 'unix'
+          # check for abstract UNIXSocket
+          UNIXSocket.new(@control_url.start_with?('unix://@') ?
+            "\0#{host}#{uri.path}" : "#{host}#{uri.path}")
+        else
+          raise "Invalid scheme: #{uri.scheme}"
+        end
+
+      if @command == 'status'
+        message 'Puma is started'
       else
-        url = "/#{@options[:command]}"
+        url = "/#{@command}"
 
-        if @options.has_key?(:control_auth_token)
-          url = url + "?token=#{@options[:control_auth_token]}"
+        if @control_auth_token
+          url = url + "?token=#{@control_auth_token}"
         end
 
-        @server << "GET #{url} HTTP/1.0\r\n\r\n"
+        server.syswrite "GET #{url} HTTP/1.0\r\n\r\n"
 
-        unless data = @server.read
-          raise "Server closed connection before responding"
+        unless data = server.read
+          raise 'Server closed connection before responding'
         end
 
         response = data.split("\r\n")
@@ -148,74 +216,105 @@ module Puma
           raise "Server sent empty response"
         end
 
-        (@http,@code,@message) = response.first.split(" ")
+        @http, @code, @message = response.first.split(' ',3)
 
-        if @code == "403"
-          raise "Unauthorized access to server (wrong auth token)"
-        elsif @code != "200"
+        if @code == '403'
+          raise 'Unauthorized access to server (wrong auth token)'
+        elsif @code == '404'
+          raise "Command error: #{response.last}"
+        elsif @code != '200'
           raise "Bad response from server: #{@code}"
         end
 
-        message "Command #{@options[:command]} sent success"
-        message response.last if @options[:command] == "stats"
+        message "Command #{@command} sent success"
+        message response.last if PRINTABLE_COMMANDS.include?(@command)
+      end
+    ensure
+      if server
+        if uri.scheme == 'ssl'
+          server.sysclose
+        else
+          server.close unless server.closed?
+        end
       end
-      
-      @server.close
     end
 
     def send_signal
-      unless pid = @options[:pid]
-        raise "Neither pid nor control url available"
+      unless @pid
+        raise 'Neither pid nor control url available'
       end
 
       begin
-        Process.getpgid pid
+        sig = CMD_PATH_SIG_MAP[@command]
+
+        if sig.nil?
+          @stdout.puts "'#{@command}' not available via pid only"
+          @stdout.flush unless @stdout.sync
+          return
+        elsif sig.start_with? 'SIG'
+          if Signal.list.key? sig.delete_prefix('SIG')
+            Process.kill sig, @pid
+          else
+            raise "Signal '#{sig}' not available'"
+          end
+        elsif @command == 'status'
+          begin
+            Process.kill 0, @pid
+            @stdout.puts 'Puma is started'
+            @stdout.flush unless @stdout.sync
+          rescue Errno::ESRCH
+            raise 'Puma is not running'
+          end
+          return
+        end
       rescue SystemCallError
-        raise "No pid '#{pid}' found"
-      end
-
-      case @options[:command]
-      when "restart"
-        Process.kill "SIGUSR2", pid
-
-      when "halt"
-        Process.kill "QUIT", pid
-
-      when "stop"
-        Process.kill "SIGTERM", pid
-
-      when "stats"
-        puts "Stats not available via pid only"
-        return
-
-      else
-        message "Puma is started"
-        return
+        if @command == 'restart'
+          start
+        else
+          raise "No pid '#{@pid}' found"
+        end
       end
 
-      message "Command #{@options[:command]} sent success"
+      message "Command #{@command} sent success"
     end
 
     def run
-      if @options[:command] == "start"
-        require 'puma/cli'
-
-        cli = Puma::CLI.new @argv, @stdout, @stderr
-        cli.run
-        return
-      end
-
+      return start if @command == 'start'
       prepare_configuration
-    
-      if is_windows?
+
+      if Puma.windows? || @control_url && !NO_REQ_COMMANDS.include?(@command)
         send_request
       else
-        @options.has_key?(:control_url) ? send_request : send_signal
+        send_signal
       end
 
     rescue => e
       message e.message
       exit 1
     end
+
+    private
+    def start
+      require_relative 'cli'
+
+      run_args = []
+
+      run_args += ["-S", @state]  if @state
+      run_args += ["-q"] if @quiet
+      run_args += ["--pidfile", @pidfile] if @pidfile
+      run_args += ["--control-url", @control_url] if @control_url
+      run_args += ["--control-token", @control_auth_token] if @control_auth_token
+      run_args += ["-C", @config_file] if @config_file
+      run_args += ["-e", @environment] if @environment
+
+      log_writer = Puma::LogWriter.new(@stdout, @stderr)
+
+      # replace $0 because puma use it to generate restart command
+      puma_cmd = $0.gsub(/pumactl$/, 'puma')
+      $0 = puma_cmd if File.exist?(puma_cmd)
+
+      cli = Puma::CLI.new run_args, log_writer
+      cli.run
+    end
   end
-end  
+end

data/lib/puma/detect.rb

@@ -1,4 +1,58 @@
+# frozen_string_literal: true
+
+# This file can be loaded independently of puma.rb, so it cannot have any code
+# that assumes puma.rb is loaded.
+
+
 module Puma
-  IS_JRUBY = defined?(JRUBY_VERSION)
-end
+  # @version 5.2.1
+  HAS_FORK = ::Process.respond_to? :fork
+
+  HAS_NATIVE_IO_WAIT = ::IO.public_instance_methods(false).include? :wait_readable
+
+  IS_JRUBY = Object.const_defined? :JRUBY_VERSION
+
+  IS_OSX = RUBY_DESCRIPTION.include? 'darwin'
+
+  IS_WINDOWS = RUBY_DESCRIPTION.match?(/mswin|ming|cygwin/)
+
+  IS_LINUX = !(IS_OSX || IS_WINDOWS)
 
+  IS_ARM = RUBY_PLATFORM.include? 'aarch64'
+
+  # @version 5.2.0
+  IS_MRI = RUBY_ENGINE == 'ruby'
+
+  def self.jruby?
+    IS_JRUBY
+  end
+
+  def self.osx?
+    IS_OSX
+  end
+
+  def self.windows?
+    IS_WINDOWS
+  end
+
+  BACKTRACE_SIGNAL =
+    if Signal.list.key?("INFO")
+      "SIGINFO"
+    elsif Signal.list.key?("PWR")
+      "SIGPWR"
+    end
+
+  # @version 5.0.0
+  def self.mri?
+    IS_MRI
+  end
+
+  # @version 5.0.0
+  def self.forkable?
+    HAS_FORK
+  end
+
+  def self.backtrace_signal
+    BACKTRACE_SIGNAL
+  end
+end