ed-precompiled_puma 7.0.4

data/lib/puma/cluster/worker.rb

@@ -0,0 +1,182 @@
+# frozen_string_literal: true
+
+module Puma
+  class Cluster < Puma::Runner
+    #—————————————————————— DO NOT USE — this class is for internal use only ———
+
+
+    # This class is instantiated by the `Puma::Cluster` and represents a single
+    # worker process.
+    #
+    # At the core of this class is running an instance of `Puma::Server` which
+    # gets created via the `start_server` method from the `Puma::Runner` class
+    # that this inherits from.
+    class Worker < Puma::Runner # :nodoc:
+      attr_reader :index, :master
+
+      def initialize(index:, master:, launcher:, pipes:, server: nil)
+        super(launcher)
+
+        @index = index
+        @master = master
+        @check_pipe = pipes[:check_pipe]
+        @worker_write = pipes[:worker_write]
+        @fork_pipe = pipes[:fork_pipe]
+        @wakeup = pipes[:wakeup]
+        @server = server
+        @hook_data = {}
+      end
+
+      def run
+        title  = "puma: cluster worker #{index}: #{master}"
+        title += " [#{@options[:tag]}]" if @options[:tag] && !@options[:tag].empty?
+        $0 = title
+
+        Signal.trap "SIGINT", "IGNORE"
+        Signal.trap "SIGCHLD", "DEFAULT"
+
+        Thread.new do
+          Puma.set_thread_name "wrkr check"
+          @check_pipe.wait_readable
+          log "! Detected parent died, dying"
+          exit! 1
+        end
+
+        # If we're not running under a Bundler context, then
+        # report the info about the context we will be using
+        if !ENV['BUNDLE_GEMFILE']
+          if File.exist?("Gemfile")
+            log "+ Gemfile in context: #{File.expand_path("Gemfile")}"
+          elsif File.exist?("gems.rb")
+            log "+ Gemfile in context: #{File.expand_path("gems.rb")}"
+          end
+        end
+
+        # Invoke any worker boot hooks so they can get
+        # things in shape before booting the app.
+        @config.run_hooks(:before_worker_boot, index, @log_writer, @hook_data)
+
+        begin
+        server = @server ||= start_server
+        rescue Exception => e
+          log "! Unable to start worker"
+          log e
+          log e.backtrace.join("\n    ")
+          exit 1
+        end
+
+        restart_server = Queue.new << true << false
+
+        fork_worker = @options[:fork_worker] && index == 0
+
+        if fork_worker
+          restart_server.clear
+          worker_pids = []
+          Signal.trap "SIGCHLD" do
+            wakeup! if worker_pids.reject! do |p|
+              Process.wait(p, Process::WNOHANG) rescue true
+            end
+          end
+
+          Thread.new do
+            Puma.set_thread_name "wrkr fork"
+            while (idx = @fork_pipe.gets)
+              idx = idx.to_i
+              if idx == -1 # stop server
+                if restart_server.length > 0
+                  restart_server.clear
+                  server.begin_restart(true)
+                  @config.run_hooks(:before_refork, nil, @log_writer, @hook_data)
+                end
+              elsif idx == -2 # refork cycle is done
+                @config.run_hooks(:after_refork, nil, @log_writer, @hook_data)
+              elsif idx == 0 # restart server
+                restart_server << true << false
+              else # fork worker
+                worker_pids << pid = spawn_worker(idx)
+                @worker_write << "#{PIPE_FORK}#{pid}:#{idx}\n" rescue nil
+              end
+            end
+          end
+        end
+
+        Signal.trap "SIGTERM" do
+          @worker_write << "#{PIPE_EXTERNAL_TERM}#{Process.pid}\n" rescue nil
+          restart_server.clear
+          server.stop
+          restart_server << false
+        end
+
+        begin
+          @worker_write << "#{PIPE_BOOT}#{Process.pid}:#{index}\n"
+        rescue SystemCallError, IOError
+          STDERR.puts "Master seems to have exited, exiting."
+          return
+        end
+
+        while restart_server.pop
+          server_thread = server.run
+
+          if @log_writer.debug? && index == 0
+            debug_loaded_extensions "Loaded Extensions - worker 0:"
+          end
+
+          stat_thread ||= Thread.new(@worker_write) do |io|
+            Puma.set_thread_name "stat pld"
+            base_payload = "#{PIPE_PING}#{Process.pid}"
+
+            while true
+              begin
+                payload = base_payload.dup
+
+                hsh = server.stats
+                hsh.each do |k, v|
+                  payload << %Q! "#{k}":#{v || 0},!
+                end
+                # sub call properly adds 'closing' string
+                io << payload.sub(/,\z/, " }\n")
+                server.reset_max
+              rescue IOError
+                break
+              end
+              sleep @options[:worker_check_interval]
+            end
+          end
+          server_thread.join
+        end
+
+        # Invoke any worker shutdown hooks so they can prevent the worker
+        # exiting until any background operations are completed
+        @config.run_hooks(:before_worker_shutdown, index, @log_writer, @hook_data)
+      ensure
+        @worker_write << "#{PIPE_TERM}#{Process.pid}\n" rescue nil
+        @worker_write.close
+      end
+
+      private
+
+      def spawn_worker(idx)
+        @config.run_hooks(:before_worker_fork, idx, @log_writer, @hook_data)
+
+        pid = fork do
+          new_worker = Worker.new index: idx,
+                                  master: master,
+                                  launcher: @launcher,
+                                  pipes: { check_pipe: @check_pipe,
+                                           worker_write: @worker_write },
+                                  server: @server
+          new_worker.run
+        end
+
+        if !pid
+          log "! Complete inability to spawn new workers detected"
+          log "! Seppuku is the only choice."
+          exit! 1
+        end
+
+        @config.run_hooks(:after_worker_fork, idx, @log_writer, @hook_data)
+        pid
+      end
+    end
+  end
+end

data/lib/puma/cluster/worker_handle.rb

@@ -0,0 +1,127 @@
+# frozen_string_literal: true
+
+module Puma
+  class Cluster < Runner
+    #—————————————————————— DO NOT USE — this class is for internal use only ———
+
+    # This class represents a worker process from the perspective of the puma
+    # master process. It contains information about the process and its health
+    # and it exposes methods to control the process via IPC. It does not
+    # include the actual logic executed by the worker process itself. For that,
+    # see Puma::Cluster::Worker.
+    class WorkerHandle # :nodoc:
+      # array of stat 'max' keys
+      WORKER_MAX_KEYS = [:backlog_max, :reactor_max]
+
+      def initialize(idx, pid, phase, options)
+        @index = idx
+        @pid = pid
+        @phase = phase
+        @stage = :started
+        @signal = "TERM"
+        @options = options
+        @first_term_sent = nil
+        @started_at = Time.now
+        @last_checkin = Time.now
+        @last_status = {}
+        @term = false
+        @worker_max = Array.new WORKER_MAX_KEYS.length, 0
+      end
+
+      attr_reader :index, :pid, :phase, :signal, :last_checkin, :last_status, :started_at, :process_status
+
+      # @version 5.0.0
+      attr_writer :pid, :phase, :process_status
+
+      def booted?
+        @stage == :booted
+      end
+
+      def uptime
+        Time.now - started_at
+      end
+
+      def boot!
+        @last_checkin = Time.now
+        @stage = :booted
+      end
+
+      def term!
+        @term = true
+      end
+
+      def term?
+        @term
+      end
+
+      def ping!(status)
+        hsh = {}
+        k, v = nil, nil
+        status.tr('}{"', '').strip.split(", ") do |kv|
+          cntr = 0
+          kv.split(':') do |t|
+            if cntr == 0
+              k = t
+              cntr = 1
+            else
+              v = t
+            end
+          end
+          hsh[k.to_sym] = v.to_i
+        end
+
+        # check stat max values, we can't signal workers to reset the max values,
+        # so we do so here
+        WORKER_MAX_KEYS.each_with_index do |key, idx|
+          next unless hsh[key]
+
+          if hsh[key] < @worker_max[idx]
+            hsh[key] = @worker_max[idx]
+          else
+            @worker_max[idx] = hsh[key]
+          end
+        end
+        @last_checkin = Time.now
+        @last_status = hsh
+      end
+
+      # Resets max values to zero.  Called whenever `Cluster#stats` is called
+      def reset_max
+        WORKER_MAX_KEYS.length.times { |idx| @worker_max[idx] = 0 }
+      end
+
+      # @see Puma::Cluster#check_workers
+      # @version 5.0.0
+      def ping_timeout
+        @last_checkin +
+          (booted? ?
+            @options[:worker_timeout] :
+            @options[:worker_boot_timeout]
+          )
+      end
+
+      def term
+        begin
+          if @first_term_sent && (Time.now - @first_term_sent) > @options[:worker_shutdown_timeout]
+            @signal = "KILL"
+          else
+            @term ||= true
+            @first_term_sent ||= Time.now
+          end
+          Process.kill @signal, @pid if @pid
+        rescue Errno::ESRCH
+        end
+      end
+
+      def kill
+        @signal = 'KILL'
+        term
+      end
+
+      def hup
+        Process.kill "HUP", @pid
+      rescue Errno::ESRCH
+      end
+    end
+  end
+end