lib/unicorn/socket_helper.rb

   1 # -*- encoding: binary -*-
   2 # :enddoc:
   3 require 'socket'
   4
   5 module Unicorn
   6   module SocketHelper
   7     # :stopdoc:
   8     include Socket::Constants
   9
  10     # prevents IO objects in here from being GC-ed
  11     IO_PURGATORY = []
  12
  13     # internal interface, only used by Rainbows!/Zbatery
  14     DEFAULTS = {
  15       # The semantics for TCP_DEFER_ACCEPT changed in Linux 2.6.32+
  16       # with commit d1b99ba41d6c5aa1ed2fc634323449dd656899e9
  17       # This change shouldn't affect Unicorn users behind nginx (a
  18       # value of 1 remains an optimization), but Rainbows! users may
  19       # want to use a higher value on Linux 2.6.32+ to protect against
  20       # denial-of-service attacks
  21       :tcp_defer_accept => 1,
  22
  23       # FreeBSD, we need to override this to 'dataready' if we
  24       # eventually get HTTPS support
  25       :accept_filter => 'httpready',
  26
  27       # same default value as Mongrel
  28       :backlog => 1024,
  29
  30       # favor latency over bandwidth savings
  31       :tcp_nopush => nil,
  32       :tcp_nodelay => true,
  33     }
  34     #:startdoc:
  35
  36     # configure platform-specific options (only tested on Linux 2.6 so far)
  37     case RUBY_PLATFORM
  38     when /linux/
  39       # from /usr/include/linux/tcp.h
  40       TCP_DEFER_ACCEPT = 9 unless defined?(TCP_DEFER_ACCEPT)
  41
  42       # do not send out partial frames (Linux)
  43       TCP_CORK = 3 unless defined?(TCP_CORK)
  44
  45       # Linux got SO_REUSEPORT in 3.9, BSDs have had it for ages
  46       unless defined?(SO_REUSEPORT)
  47         if RUBY_PLATFORM =~ /(?:alpha|mips|parisc|sparc)/
  48           SO_REUSEPORT = 0x0200 # untested
  49         else
  50           SO_REUSEPORT = 15 # only tested on x86_64 and i686
  51         end
  52       end
  53     when /freebsd/
  54       # do not send out partial frames (FreeBSD)
  55       TCP_NOPUSH = 4 unless defined?(TCP_NOPUSH)
  56
  57       def accf_arg(af_name)
  58         [ af_name, nil ].pack('a16a240')
  59       end if defined?(SO_ACCEPTFILTER)
  60     end
  61
  62     def set_tcp_sockopt(sock, opt)
  63       # just in case, even LANs can break sometimes.  Linux sysadmins
  64       # can lower net.ipv4.tcp_keepalive_* sysctl knobs to very low values.
  65       sock.setsockopt(SOL_SOCKET, SO_KEEPALIVE, 1) if defined?(SO_KEEPALIVE)
  66
  67       if defined?(TCP_NODELAY)
  68         val = opt[:tcp_nodelay]
  69         val = DEFAULTS[:tcp_nodelay] if nil == val
  70         sock.setsockopt(IPPROTO_TCP, TCP_NODELAY, val ? 1 : 0)
  71       end
  72
  73       val = opt[:tcp_nopush]
  74       unless val.nil?
  75         if defined?(TCP_CORK) # Linux
  76           sock.setsockopt(IPPROTO_TCP, TCP_CORK, val)
  77         elsif defined?(TCP_NOPUSH) # TCP_NOPUSH is lightly tested (FreeBSD)
  78           sock.setsockopt(IPPROTO_TCP, TCP_NOPUSH, val)
  79         end
  80       end
  81
  82       # No good reason to ever have deferred accepts off
  83       # (except maybe benchmarking)
  84       if defined?(TCP_DEFER_ACCEPT)
  85         # this differs from nginx, since nginx doesn't allow us to
  86         # configure the the timeout...
  87         seconds = opt[:tcp_defer_accept]
  88         seconds = DEFAULTS[:tcp_defer_accept] if [true,nil].include?(seconds)
  89         seconds = 0 unless seconds # nil/false means disable this
  90         sock.setsockopt(SOL_TCP, TCP_DEFER_ACCEPT, seconds)
  91       elsif respond_to?(:accf_arg)
  92         name = opt[:accept_filter]
  93         name = DEFAULTS[:accept_filter] if nil == name
  94         begin
  95           sock.setsockopt(SOL_SOCKET, SO_ACCEPTFILTER, accf_arg(name))
  96         rescue => e
  97           logger.error("#{sock_name(sock)} " \
  98                        "failed to set accept_filter=#{name} (#{e.inspect})")
  99         end
 100       end
 101     end
 102
 103     def set_server_sockopt(sock, opt)
 104       opt = DEFAULTS.merge(opt || {})
 105
 106       TCPSocket === sock and set_tcp_sockopt(sock, opt)
 107
 108       if opt[:rcvbuf] || opt[:sndbuf]
 109         log_buffer_sizes(sock, "before: ")
 110         sock.setsockopt(SOL_SOCKET, SO_RCVBUF, opt[:rcvbuf]) if opt[:rcvbuf]
 111         sock.setsockopt(SOL_SOCKET, SO_SNDBUF, opt[:sndbuf]) if opt[:sndbuf]
 112         log_buffer_sizes(sock, " after: ")
 113       end
 114       sock.listen(opt[:backlog])
 115       rescue => e
 116         Unicorn.log_error(logger, "#{sock_name(sock)} #{opt.inspect}", e)
 117     end
 118
 119     def log_buffer_sizes(sock, pfx = '')
 120       rcvbuf = sock.getsockopt(SOL_SOCKET, SO_RCVBUF).unpack('i')
 121       sndbuf = sock.getsockopt(SOL_SOCKET, SO_SNDBUF).unpack('i')
 122       logger.info "#{pfx}#{sock_name(sock)} rcvbuf=#{rcvbuf} sndbuf=#{sndbuf}"
 123     end
 124
 125     # creates a new server, socket. address may be a HOST:PORT or
 126     # an absolute path to a UNIX socket.  address can even be a Socket
 127     # object in which case it is immediately returned
 128     def bind_listen(address = '0.0.0.0:8080', opt = {})
 129       return address unless String === address
 130
 131       sock = if address[0] == ?/
 132         if File.exist?(address)
 133           if File.socket?(address)
 134             begin
 135               UNIXSocket.new(address).close
 136               # fall through, try to bind(2) and fail with EADDRINUSE
 137               # (or succeed from a small race condition we can't sanely avoid).
 138             rescue Errno::ECONNREFUSED
 139               logger.info "unlinking existing socket=#{address}"
 140               File.unlink(address)
 141             end
 142           else
 143             raise ArgumentError,
 144                   "socket=#{address} specified but it is not a socket!"
 145           end
 146         end
 147         old_umask = File.umask(opt[:umask] || 0)
 148         begin
 149           Kgio::UNIXServer.new(address)
 150         ensure
 151           File.umask(old_umask)
 152         end
 153       elsif /\A\[([a-fA-F0-9:]+)\]:(\d+)\z/ =~ address
 154         new_tcp_server($1, $2.to_i, opt.merge(:ipv6=>true))
 155       elsif /\A(\d+\.\d+\.\d+\.\d+):(\d+)\z/ =~ address
 156         new_tcp_server($1, $2.to_i, opt)
 157       else
 158         raise ArgumentError, "Don't know how to bind: #{address}"
 159       end
 160       set_server_sockopt(sock, opt)
 161       sock
 162     end
 163
 164     def new_tcp_server(addr, port, opt)
 165       # n.b. we set FD_CLOEXEC in the workers
 166       sock = Socket.new(opt[:ipv6] ? AF_INET6 : AF_INET, SOCK_STREAM, 0)
 167       if opt.key?(:ipv6only)
 168         defined?(IPV6_V6ONLY) or
 169           abort "Socket::IPV6_V6ONLY not defined, upgrade Ruby and/or your OS"
 170         sock.setsockopt(IPPROTO_IPV6, IPV6_V6ONLY, opt[:ipv6only] ? 1 : 0)
 171       end
 172       sock.setsockopt(SOL_SOCKET, SO_REUSEADDR, 1)
 173       if defined?(SO_REUSEPORT) && opt[:reuseport]
 174         sock.setsockopt(SOL_SOCKET, SO_REUSEPORT, 1)
 175       end
 176       sock.bind(Socket.pack_sockaddr_in(port, addr))
 177       IO_PURGATORY << sock
 178       Kgio::TCPServer.for_fd(sock.fileno)
 179     end
 180
 181     # returns rfc2732-style (e.g. "[::1]:666") addresses for IPv6
 182     def tcp_name(sock)
 183       port, addr = Socket.unpack_sockaddr_in(sock.getsockname)
 184       /:/ =~ addr ? "[#{addr}]:#{port}" : "#{addr}:#{port}"
 185     end
 186     module_function :tcp_name
 187
 188     # Returns the configuration name of a socket as a string.  sock may
 189     # be a string value, in which case it is returned as-is
 190     # Warning: TCP sockets may not always return the name given to it.
 191     def sock_name(sock)
 192       case sock
 193       when String then sock
 194       when UNIXServer
 195         Socket.unpack_sockaddr_un(sock.getsockname)
 196       when TCPServer
 197         tcp_name(sock)
 198       when Socket
 199         begin
 200           tcp_name(sock)
 201         rescue ArgumentError
 202           Socket.unpack_sockaddr_un(sock.getsockname)
 203         end
 204       else
 205         raise ArgumentError, "Unhandled class #{sock.class}: #{sock.inspect}"
 206       end
 207     end
 208
 209     module_function :sock_name
 210
 211     # casts a given Socket to be a TCPServer or UNIXServer
 212     def server_cast(sock)
 213       begin
 214         Socket.unpack_sockaddr_in(sock.getsockname)
 215         Kgio::TCPServer.for_fd(sock.fileno)
 216       rescue ArgumentError
 217         Kgio::UNIXServer.for_fd(sock.fileno)
 218       end
 219     end
 220
 221   end # module SocketHelper
 222 end # module Unicorn