pitchfork 0.1.0

data/lib/pitchfork/launcher.rb

@@ -0,0 +1,9 @@
+# -*- encoding: binary -*-
+
+# :enddoc:
+$stdout.sync = $stderr.sync = true
+$stdin.binmode
+$stdout.binmode
+$stderr.binmode
+
+require 'pitchfork'

data/lib/pitchfork/mem_info.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module Pitchfork
+  class MemInfo
+    attr_reader :rss, :pss, :shared_memory
+
+    def initialize(pid)
+      @pid = pid
+      update
+    end
+
+    def cow_efficiency(parent_meminfo)
+      shared_memory.to_f / parent_meminfo.rss * 100.0
+    end
+
+    def update
+      info = parse(File.read("/proc/#{@pid}/smaps_rollup"))
+      @pss = info.fetch(:Pss)
+      @rss = info.fetch(:Rss)
+      @shared_memory = info.fetch(:Shared_Clean) + info.fetch(:Shared_Dirty)
+      self
+    end
+
+    private
+
+    def parse(rollup)
+      fields = {}
+      rollup.each_line do |line|
+        if (matchdata = line.match(/(?<field>\w+)\:\s+(?<size>\d+) kB$/))
+          fields[matchdata[:field].to_sym] = matchdata[:size].to_i
+        end
+      end
+      fields
+    end
+  end
+end

data/lib/pitchfork/message.rb

@@ -0,0 +1,130 @@
+# -*- encoding: binary -*-
+
+# :stopdoc:
+module Pitchfork
+  class MessageSocket
+    unless respond_to?(:ruby2_keywords, true)
+      class << self
+        def ruby2_keywords(*args)
+          args
+        end
+      end
+    end
+
+    FD = Struct.new(:index)
+
+    def initialize(socket)
+      @socket = socket
+    end
+
+    def to_io
+      @socket
+    end
+
+    def wait(*args)
+      @socket.wait(*args)
+    end
+    ruby2_keywords :wait
+
+    def close_read
+      @socket.close_read
+    end
+
+    def close_write
+      @socket.close_write
+    end
+
+    def close
+      @socket.close
+    end
+
+    def sendmsg(message)
+      payload, ios = dump_message(message)
+      @socket.sendmsg(
+        payload,
+        0,
+        nil,
+        *ios.map { |io| Socket::AncillaryData.unix_rights(io) },
+      )
+    end
+
+    def sendmsg_nonblock(message, exception: true)
+      payload, ios = dump_message(message)
+      @socket.sendmsg_nonblock(
+        payload,
+        0,
+        nil,
+        *ios.map { |io| Socket::AncillaryData.unix_rights(io) },
+        exception: exception,
+      )
+    end
+
+    def recvmsg_nonblock(exception: true)
+      case message = @socket.recvmsg_nonblock(scm_rights: true, exception: exception)
+      when Array
+        load_message(message)
+      else
+        message
+      end
+    end
+
+    private
+
+    MARSHAL_PREFIX = (Marshal::MAJOR_VERSION.chr << Marshal::MINOR_VERSION.chr).freeze
+
+    def load_message(message)
+      payload, _, _, data = message
+
+      if payload.empty?
+        # EOF: Ruby return an empty packet on closed connection
+        # https://bugs.ruby-lang.org/issues/19012
+        return nil
+      end
+
+      unless payload.start_with?(MARSHAL_PREFIX)
+        return payload
+      end
+
+      klass, *args = Marshal.load(payload)
+      args.map! do |arg|
+        if arg.is_a?(FD)
+          data.unix_rights.fetch(arg.index)
+        else
+          arg
+        end
+      end
+
+      klass.new(*args)
+    end
+
+    def dump_message(message)
+      return [message, []] unless message.is_a?(Message)
+
+      args = message.to_a
+      ios = args.select { |arg| arg.is_a?(IO) || arg.is_a?(MessageSocket) }
+
+      io_index = 0
+      args.map! do |arg|
+        if arg.is_a?(IO) || arg.is_a?(MessageSocket)
+          fd = FD.new(io_index)
+          io_index += 1
+          fd
+        else
+          arg
+        end
+      end
+
+      [Marshal.dump([message.class, *args]), ios.map(&:to_io)]
+    end
+  end
+
+  Message = Class.new(Struct)
+  class Message
+    SpawnWorker = Message.new(:nr)
+    WorkerSpawned = Message.new(:nr, :pid, :generation, :pipe)
+    PromoteWorker = Message.new(:generation)
+    WorkerPromoted = Message.new(:nr, :pid, :generation)
+
+    SoftKill = Message.new(:signum)
+  end
+end

data/lib/pitchfork/mold_selector.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module Pitchfork
+  module MoldSelector
+    class LeastSharedMemory
+      def call(server)
+        workers = server.children.fresh_workers
+        if workers.empty?
+          server.logger.info("No current generation workers yet")
+          return
+        end
+        candidate = workers.shift
+
+        workers.each do |worker|
+          if worker.meminfo.shared_memory < candidate.meminfo.shared_memory
+            # We suppose that a worker with a lower amount of shared memory
+            # has warmed up more caches & such, hence is closer to stabilize
+            # making it a better candidate.
+            candidate = worker
+          end
+        end
+        parent_meminfo = server.children.mold&.meminfo || MemInfo.new(Process.pid)
+        cow_efficiency = candidate.meminfo.cow_efficiency(parent_meminfo)
+        server.logger.info("worker=#{candidate.nr} pid=#{candidate.pid} selected as new mold shared_memory_kb=#{candidate.meminfo.shared_memory} cow=#{cow_efficiency.round(1)}%")
+        candidate
+      end
+    end
+  end
+end

data/lib/pitchfork/preread_input.rb

@@ -0,0 +1,33 @@
+# -*- encoding: binary -*-
+
+module Pitchfork
+  # This middleware is used to ensure input is buffered to memory
+  # or disk (depending on size) before the application is dispatched
+  # by entirely consuming it (from TeeInput) beforehand.
+  #
+  # Usage (in config.ru):
+  #
+  #     require 'pitchfork/preread_input'
+  #     if defined?(Pitchfork)
+  #       use Pitchfork::PrereadInput
+  #     end
+  #     run YourApp.new
+  class PrereadInput
+
+    # :stopdoc:
+    def initialize(app)
+      @app = app
+    end
+
+    def call(env)
+      buf = ""
+      input = env["rack.input"]
+      if input.respond_to?(:rewind)
+        true while input.read(16384, buf)
+        input.rewind
+      end
+      @app.call(env)
+    end
+    # :startdoc:
+  end
+end

data/lib/pitchfork/refork_condition.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module Pitchfork
+  module ReforkCondition
+    class RequestsCount
+      def initialize(request_counts)
+        @limits = request_counts
+      end
+
+      def met?(children, logger)
+        if limit = @limits[children.last_generation]
+          if worker = children.fresh_workers.find { |w| w.requests_count >= limit }
+            logger.info("worker=#{worker.nr} pid=#{worker.pid} processed #{worker.requests_count} requests, triggering a refork")
+            return true
+          end
+        end
+        false
+      end
+    end
+  end
+end

data/lib/pitchfork/select_waiter.rb

@@ -0,0 +1,9 @@
+module Pitchfork
+  # fallback for non-Linux and Linux <4.5 systems w/o EPOLLEXCLUSIVE
+  class SelectWaiter # :nodoc:
+    def get_readers(ready, readers, timeout_msec) # :nodoc:
+      timeout_sec = timeout_msec / 1_000.0
+      ret = IO.select(readers, nil, nil, timeout_sec) and ready.replace(ret[0])
+    end
+  end
+end

data/lib/pitchfork/socket_helper.rb

@@ -0,0 +1,199 @@
+# -*- encoding: binary -*-
+# :enddoc:
+require 'socket'
+
+module Pitchfork
+  module SocketHelper
+
+    # internal interface
+    DEFAULTS = {
+      # The semantics for TCP_DEFER_ACCEPT changed in Linux 2.6.32+
+      # with commit d1b99ba41d6c5aa1ed2fc634323449dd656899e9
+      # This change shouldn't affect pitchfork users behind nginx (a
+      # value of 1 remains an optimization).
+      :tcp_defer_accept => 1,
+
+      # FreeBSD, we need to override this to 'dataready' if we
+      # eventually support non-HTTP/1.x
+      :accept_filter => 'httpready',
+
+      # same default value as Mongrel
+      :backlog => 1024,
+
+      # favor latency over bandwidth savings
+      :tcp_nopush => nil,
+      :tcp_nodelay => true,
+    }
+
+    # configure platform-specific options (only tested on Linux 2.6 so far)
+    def accf_arg(af_name)
+      [ af_name, nil ].pack('a16a240')
+    end if RUBY_PLATFORM =~ /freebsd/ && Socket.const_defined?(:SO_ACCEPTFILTER)
+
+    def set_tcp_sockopt(sock, opt)
+      # just in case, even LANs can break sometimes.  Linux sysadmins
+      # can lower net.ipv4.tcp_keepalive_* sysctl knobs to very low values.
+      Socket.const_defined?(:SO_KEEPALIVE) and
+        sock.setsockopt(:SOL_SOCKET, :SO_KEEPALIVE, 1)
+
+      if Socket.const_defined?(:TCP_NODELAY)
+        val = opt[:tcp_nodelay]
+        val = DEFAULTS[:tcp_nodelay] if val.nil?
+        sock.setsockopt(:IPPROTO_TCP, :TCP_NODELAY, val ? 1 : 0)
+      end
+
+      val = opt[:tcp_nopush]
+      unless val.nil?
+        if Socket.const_defined?(:TCP_CORK) # Linux
+          sock.setsockopt(:IPPROTO_TCP, :TCP_CORK, val)
+        elsif Socket.const_defined?(:TCP_NOPUSH) # FreeBSD
+          sock.setsockopt(:IPPROTO_TCP, :TCP_NOPUSH, val)
+        end
+      end
+
+      # No good reason to ever have deferred accepts off in single-threaded
+      # servers (except maybe benchmarking)
+      if Socket.const_defined?(:TCP_DEFER_ACCEPT)
+        # this differs from nginx, since nginx doesn't allow us to
+        # configure the the timeout...
+        seconds = opt[:tcp_defer_accept]
+        seconds = DEFAULTS[:tcp_defer_accept] if [true,nil].include?(seconds)
+        seconds = 0 unless seconds # nil/false means disable this
+        sock.setsockopt(:IPPROTO_TCP, :TCP_DEFER_ACCEPT, seconds)
+      elsif respond_to?(:accf_arg)
+        name = opt[:accept_filter]
+        name = DEFAULTS[:accept_filter] if name.nil?
+        sock.listen(opt[:backlog])
+        got = (sock.getsockopt(:SOL_SOCKET, :SO_ACCEPTFILTER) rescue nil).to_s
+        arg = accf_arg(name)
+        begin
+          sock.setsockopt(:SOL_SOCKET, :SO_ACCEPTFILTER, arg)
+        rescue => e
+          logger.error("#{sock_name(sock)} " \
+                       "failed to set accept_filter=#{name} (#{e.inspect})")
+          logger.error("perhaps accf_http(9) needs to be loaded".freeze)
+        end if arg != got
+      end
+    end
+
+    def set_server_sockopt(sock, opt)
+      opt = DEFAULTS.merge(opt || {})
+
+      TCPSocket === sock and set_tcp_sockopt(sock, opt)
+
+      rcvbuf, sndbuf = opt.values_at(:rcvbuf, :sndbuf)
+      if rcvbuf || sndbuf
+        log_buffer_sizes(sock, "before: ")
+        sock.setsockopt(:SOL_SOCKET, :SO_RCVBUF, rcvbuf) if rcvbuf
+        sock.setsockopt(:SOL_SOCKET, :SO_SNDBUF, sndbuf) if sndbuf
+        log_buffer_sizes(sock, " after: ")
+      end
+      sock.listen(opt[:backlog])
+    rescue => e
+      Pitchfork.log_error(logger, "#{sock_name(sock)} #{opt.inspect}", e)
+    end
+
+    def log_buffer_sizes(sock, pfx = '')
+      rcvbuf = sock.getsockopt(:SOL_SOCKET, :SO_RCVBUF).int
+      sndbuf = sock.getsockopt(:SOL_SOCKET, :SO_SNDBUF).int
+      logger.info "#{pfx}#{sock_name(sock)} rcvbuf=#{rcvbuf} sndbuf=#{sndbuf}"
+    end
+
+    # creates a new server, socket. address may be a HOST:PORT or
+    # an absolute path to a UNIX socket.  address can even be a Socket
+    # object in which case it is immediately returned
+    def bind_listen(address = '0.0.0.0:8080', opt = {})
+      return address unless String === address
+
+      sock = if address.start_with?('/')
+        if File.exist?(address)
+          if File.socket?(address)
+            begin
+              UNIXSocket.new(address).close
+              # fall through, try to bind(2) and fail with EADDRINUSE
+              # (or succeed from a small race condition we can't sanely avoid).
+            rescue Errno::ECONNREFUSED
+              logger.info "unlinking existing socket=#{address}"
+              File.unlink(address)
+            end
+          else
+            raise ArgumentError,
+                  "socket=#{address} specified but it is not a socket!"
+          end
+        end
+        old_umask = File.umask(opt[:umask] || 0)
+        begin
+          UNIXServer.new(address)
+        ensure
+          File.umask(old_umask)
+        end
+      elsif /\A\[([a-fA-F0-9:]+)\]:(\d+)\z/ =~ address
+        new_tcp_server($1, $2.to_i, opt.merge(:ipv6=>true))
+      elsif /\A(\d+\.\d+\.\d+\.\d+):(\d+)\z/ =~ address
+        new_tcp_server($1, $2.to_i, opt)
+      else
+        raise ArgumentError, "Don't know how to bind: #{address}"
+      end
+      set_server_sockopt(sock, opt)
+      sock
+    end
+
+    def new_tcp_server(addr, port, opt)
+      # n.b. we set FD_CLOEXEC in the workers
+      sock = Socket.new(opt[:ipv6] ? :AF_INET6 : :AF_INET, :SOCK_STREAM)
+      if opt.key?(:ipv6only)
+        Socket.const_defined?(:IPV6_V6ONLY) or
+          abort "Socket::IPV6_V6ONLY not defined, upgrade Ruby and/or your OS"
+        sock.setsockopt(:IPPROTO_IPV6, :IPV6_V6ONLY, opt[:ipv6only] ? 1 : 0)
+      end
+      sock.setsockopt(:SOL_SOCKET, :SO_REUSEADDR, 1)
+      if Socket.const_defined?(:SO_REUSEPORT) && opt[:reuseport]
+        sock.setsockopt(:SOL_SOCKET, :SO_REUSEPORT, 1)
+      end
+      sock.bind(Socket.pack_sockaddr_in(port, addr))
+      sock.autoclose = false
+      TCPServer.for_fd(sock.fileno)
+    end
+
+    # returns rfc2732-style (e.g. "[::1]:666") addresses for IPv6
+    def tcp_name(sock)
+      port, addr = Socket.unpack_sockaddr_in(sock.getsockname)
+      addr.include?(':') ? "[#{addr}]:#{port}" : "#{addr}:#{port}"
+    end
+    module_function :tcp_name
+
+    # Returns the configuration name of a socket as a string.  sock may
+    # be a string value, in which case it is returned as-is
+    # Warning: TCP sockets may not always return the name given to it.
+    def sock_name(sock)
+      case sock
+      when String then sock
+      when UNIXServer
+        Socket.unpack_sockaddr_un(sock.getsockname)
+      when TCPServer
+        tcp_name(sock)
+      when Socket
+        begin
+          tcp_name(sock)
+        rescue ArgumentError
+          Socket.unpack_sockaddr_un(sock.getsockname)
+        end
+      else
+        raise ArgumentError, "Unhandled class #{sock.class}: #{sock.inspect}"
+      end
+    end
+
+    module_function :sock_name
+
+    # casts a given Socket to be a TCPServer or UNIXServer
+    def server_cast(sock)
+      begin
+        Socket.unpack_sockaddr_in(sock.getsockname)
+        TCPServer.for_fd(sock.fileno)
+      rescue ArgumentError
+        UNIXServer.for_fd(sock.fileno)
+      end
+    end
+
+  end # module SocketHelper
+end # module Pitchfork

data/lib/pitchfork/stream_input.rb

@@ -0,0 +1,152 @@
+# -*- encoding: binary -*-
+
+module Pitchfork
+  # When processing uploads, pitchfork may expose a StreamInput object under
+  # "rack.input" of the Rack environment when
+  # Pitchfork::Configurator#rewindable_input is set to +false+
+  class StreamInput
+    # The I/O chunk size (in +bytes+) for I/O operations where
+    # the size cannot be user-specified when a method is called.
+    # The default is 16 kilobytes.
+    @@io_chunk_size = Pitchfork::Const::CHUNK_SIZE # :nodoc:
+
+    # Initializes a new StreamInput object.  You normally do not have to call
+    # this unless you are writing an HTTP server.
+    def initialize(socket, request) # :nodoc:
+      @chunked = request.content_length.nil?
+      @socket = socket
+      @parser = request
+      @buf = request.buf
+      @rbuf = ''
+      @bytes_read = 0
+      filter_body(@rbuf, @buf) unless @buf.empty?
+    end
+
+    # :call-seq:
+    #   ios.read([length [, buffer ]]) => string, buffer, or nil
+    #
+    # Reads at most length bytes from the I/O stream, or to the end of
+    # file if length is omitted or is nil. length must be a non-negative
+    # integer or nil. If the optional buffer argument is present, it
+    # must reference a String, which will receive the data.
+    #
+    # At end of file, it returns nil or '' depend on length.
+    # ios.read() and ios.read(nil) returns ''.
+    # ios.read(length [, buffer]) returns nil.
+    #
+    # If the Content-Length of the HTTP request is known (as is the common
+    # case for POST requests), then ios.read(length [, buffer]) will block
+    # until the specified length is read (or it is the last chunk).
+    # Otherwise, for uncommon "Transfer-Encoding: chunked" requests,
+    # ios.read(length [, buffer]) will return immediately if there is
+    # any data and only block when nothing is available (providing
+    # IO#readpartial semantics).
+    def read(length = nil, rv = '')
+      if length
+        if length <= @rbuf.size
+          length < 0 and raise ArgumentError, "negative length #{length} given"
+          rv.replace(@rbuf.slice!(0, length))
+        else
+          to_read = length - @rbuf.size
+          rv.replace(@rbuf.slice!(0, @rbuf.size))
+          until to_read == 0 || eof? || (rv.size > 0 && @chunked)
+            begin
+              @socket.readpartial(to_read, @buf)
+            rescue EOFError
+              eof!
+            end
+            filter_body(@rbuf, @buf)
+            rv << @rbuf
+            to_read -= @rbuf.size
+          end
+          @rbuf.clear
+        end
+        rv = nil if rv.empty? && length != 0
+      else
+        read_all(rv)
+      end
+      rv
+    end
+
+    # :call-seq:
+    #   ios.gets   => string or nil
+    #
+    # Reads the next ``line'' from the I/O stream; lines are separated
+    # by the global record separator ($/, typically "\n"). A global
+    # record separator of nil reads the entire unread contents of ios.
+    # Returns nil if called at the end of file.
+    # This takes zero arguments for strict Rack::Lint compatibility,
+    # unlike IO#gets.
+    def gets(sep = $/)
+      if sep.nil?
+        read_all(rv = '')
+        return rv.empty? ? nil : rv
+      end
+      re = /\A(.*?#{Regexp.escape(sep)})/
+
+      begin
+        @rbuf.sub!(re, '') and return $1
+        return @rbuf.empty? ? nil : @rbuf.slice!(0, @rbuf.size) if eof?
+        @socket.readpartial(@@io_chunk_size, @buf) or eof!
+        filter_body(once = '', @buf)
+        @rbuf << once
+      end while true
+    end
+
+    # :call-seq:
+    #   ios.each { |line| block }  => ios
+    #
+    # Executes the block for every ``line'' in *ios*, where lines are
+    # separated by the global record separator ($/, typically "\n").
+    def each
+      while line = gets
+        yield line
+      end
+
+      self # Rack does not specify what the return value is here
+    end
+
+  private
+
+    def eof?
+      if @parser.body_eof?
+        while @chunked && ! @parser.parse
+          once = @socket.readpartial(@@io_chunk_size) or eof!
+          @buf << once
+        end
+        @socket = nil
+        true
+      else
+        false
+      end
+    end
+
+    def filter_body(dst, src)
+      rv = @parser.filter_body(dst, src)
+      @bytes_read += dst.size
+      rv
+    end
+
+    def read_all(dst)
+      dst.replace(@rbuf)
+      @socket or return
+      until eof?
+        @socket.readpartial(@@io_chunk_size, @buf) or eof!
+        filter_body(@rbuf, @buf)
+        dst << @rbuf
+      end
+    ensure
+      @rbuf.clear
+    end
+
+    def eof!
+      # in case client only did a premature shutdown(SHUT_WR)
+      # we do support clients that shutdown(SHUT_WR) after the
+      # _entire_ request has been sent, and those will not have
+      # raised EOFError on us.
+      @socket.shutdown if @socket
+    ensure
+      raise Pitchfork::ClientShutdown, "bytes_read=#{@bytes_read}", []
+    end
+  end
+end