Refactor Reel::Server, refactor/retrofit/abandon SocketMixin

README.md

@@ -18,7 +18,8 @@ traditional multithreaded blocking I/O support too.
 [nio4r]: https://github.com/celluloid/nio4r
 
 Connections to Reel can be either non-blocking and handled entirely within
-the Reel::Server thread, or the same connections can be dispatched to worker
+the Reel::Server thread ( handling HTTP, SSL, or UNIX sockets ),
+or the same connections can be dispatched to worker
 threads where they will perform ordinary blocking IO. Reel provides no
 built-in thread pool, however you can build one yourself using Celluloid.pool,
 or because Celluloid already pools threads to begin with, you can simply use
@@ -132,7 +133,7 @@ Reel lets you pass a block to initialize which receives connections:
 ```ruby
 require 'reel'
 
-Reel::Server.supervise("0.0.0.0", 3000) do |connection|
+Reel::HTTPServer.supervise("0.0.0.0", 3000) do |connection|
   # Support multiple keep-alive requests per connection
   connection.each_request do |request|
     # WebSocket support
@@ -163,7 +164,7 @@ You can also subclass Reel, which allows additional customizations:
 ```ruby
 require 'reel'
 
-class MyServer < Reel::Server
+class MyServer < Reel::HTTPServer
   def initialize(host = "127.0.0.1", port = 3000)
     super(host, port, &method(:on_connection))
   end

benchmarks/hello_reel.rb

@@ -5,7 +5,7 @@
 addr, port = '127.0.0.1', 1234
 
 puts "*** Starting server on #{addr}:#{port}"
-Reel::Server.new(addr, port) do |connection|
+Reel::HTTPServer.new(addr, port) do |connection|
   connection.respond :ok, "Hello World"
 end
 

benchmarks/reel_pool.rb

@@ -17,7 +17,7 @@ def handle_request(request)
 
 connectionPool = MyConnectionHandler.pool
 
-Reel::Server.run('127.0.0.1', 3000) do |connection|
+Reel::HTTPServer.run('127.0.0.1', 3000) do |connection|
   # We're handing this connection off to another actor, so
   # we detach it first before handing it off
   connection.detach

examples/hello_world.rb

@@ -8,7 +8,7 @@
 addr, port = '127.0.0.1', 1234
 
 puts "*** Starting server on http://#{addr}:#{port}"
-Reel::Server.run(addr, port) do |connection|
+Reel::HTTPServer.run(addr, port) do |connection|
   # For keep-alive support
   connection.each_request do |request|
     # Ordinarily we'd route the request here, e.g.

examples/roundtrip.rb

@@ -61,7 +61,7 @@ def new_message(topic)
   end
 end
 
-class WebServer < Reel::Server
+class WebServer < Reel::HTTPServer
   include Celluloid::Logger
 
   def initialize(host = "0.0.0.0", port = 9000)

examples/server_sent_events.rb

@@ -8,7 +8,7 @@
 require 'reel'
 
 
-class ServerSentEvents < Reel::Server
+class ServerSentEvents < Reel::HTTPServer
   include Celluloid::Logger
 
   def initialize(ip = '127.0.0.1', port = 63310)

examples/spy_hello_world.rb

@@ -8,7 +8,7 @@
 addr, port = '127.0.0.1', 1234
 
 puts "*** Starting server on http://#{addr}:#{port}"
-Reel::Server.run(addr, port, spy: true) do |connection|
+Reel::HTTPServer.run(addr, port, spy: true) do |connection|
   # For keep-alive support
   connection.each_request do |request|
     # Ordinarily we'd route the request here, e.g.

examples/websockets.rb

@@ -38,7 +38,7 @@ def notify_time_change(topic, new_time)
   end
 end
 
-class WebServer < Reel::Server
+class WebServer < Reel::HTTPServer
   include Celluloid::Logger
 
   def initialize(host = "127.0.0.1", port = 1234)
@@ -53,11 +53,11 @@ def on_connection(connection)
 
         # We're going to hand off this connection to another actor (TimeClient)
         # However, initially Reel::Connections are "attached" to the
-        # Reel::Server actor, meaning that the server manages the connection
+        # Reel::HTTPServer actor, meaning that the server manages the connection
         # lifecycle (e.g. error handling) for us.
         # 
         # If we want to hand this connection off to another actor, we first
-        # need to detach it from the Reel::Server
+        # need to detach it from the Reel::Server ( in this case, Reel::HTTPServer )
         connection.detach
 
         route_websocket request.websocket

lib/reel.rb

@@ -10,8 +10,12 @@
 require 'reel/logger'
 require 'reel/request'
 require 'reel/response'
+
 require 'reel/server'
-require 'reel/ssl_server'
+require 'reel/server/http'
+require 'reel/server/ssl'
+require 'reel/server/unix'
+
 require 'reel/websocket'
 require 'reel/stream'
 

lib/reel/mixins.rb

@@ -19,6 +19,7 @@ def remote_host
       # NOTE: Celluloid::IO does not yet support non-blocking reverse DNS
       socket.peeraddr(true)[2]
     end
+
   end
 
   module RequestMixin
@@ -60,4 +61,51 @@ def fragment
     end
 
   end
+
+  module SocketMixin
+
+    # Optimizations possible, depending on OS:
+
+    # TCP_NODELAY:    prevent TCP packets from being buffered
+    # TCP_CORK:       TODO: tersely describe
+    # SO_REUSEADDR:   TODO: tersely describe
+
+    if RUBY_PLATFORM =~ /linux/
+
+      # Only Linux supports the mix of socket behaviors given in these optimizations.
+      # Beaware, certain optimizations may work individually off Linux; not together.
+      def optimize_socket socket
+        if socket.is_a? TCPSocket
+          socket.setsockopt( Socket::IPPROTO_TCP, :TCP_NODELAY, 1 )
+          socket.setsockopt( Socket::IPPROTO_TCP, 3, 1 ) # TCP_CORK
+          socket.setsockopt( Socket::SOL_SOCKET, Socket::SO_REUSEADDR, 1 )
+        end
+      end
+
+      def deoptimize_socket socket
+        if socket.is_a? TCPSocket
+          socket.setsockopt( Socket::IPPROTO_TCP, :TCP_NODELAY, 1 )
+          socket.setsockopt( Socket::IPPROTO_TCP, 3, 1 ) # TCP_CORK
+          socket.setsockopt( Socket::SOL_SOCKET, Socket::SO_REUSEADDR, 1 )
+        end
+      end
+
+    else
+
+      # If the underying OS is not Linux, apply the remaining available optimizations.
+      def optimize_socket socket
+        if socket.is_a? TCPSocket
+          socket.setsockopt( Socket::IPPROTO_TCP, :TCP_NODELAY, 1 )
+        end
+      end
+
+      def deoptimize_socket socket
+        if socket.is_a? TCPSocket
+          socket.setsockopt( Socket::IPPROTO_TCP, :TCP_NODELAY, 0 )
+        end
+      end
+    end
+
+  end
+
 end

lib/reel/server.rb

@@ -1,71 +1,36 @@
 module Reel
-  # The Reel HTTP server class
+  # The Reel server ( foundation ) class
   #
-  # This class is a Celluloid::IO actor which provides a bareboens HTTP server
-  # For HTTPS support, use Reel::SSLServer
+  # This class is a Celluloid::IO actor which provides a barebones server
+  # which does not open a socket itself, it just begin handling connections once
+  # initialized with a specific kind of protocol-based server.
+
+  # For specific protocol support, use:
+
+  # Reel::HTTPServer
+  # Reel::SSLServer
+  # Reel::UNIXServer
+
   class Server
     include Celluloid::IO
+    include SocketMixin
 
     # How many connections to backlog in the TCP accept queue
     DEFAULT_BACKLOG = 100
 
     execute_block_on_receiver :initialize
     finalizer :shutdown
 
-    # Allow the existing `new` to be called, even though we will
-    # replace it with a default version that creates HTTP servers over
-    # TCP sockets.
-    #
-    class << self
-      alias_method :_new, :new
-      protected    :_new
-    end
-
-    # Create a new Reel HTTP server
-    #
-    # @param [String] host address to bind to
-    # @param [Fixnum] port to bind to
-    # @option options [Fixnum] backlog of requests to accept
-    # @option options [true] spy on the request
-    #
-    # @return [Reel::SSLServer] Reel HTTPS server actor
-    #
-    # ::new was overridden for backwards compatibility. The underlying
-    # #initialize method now accepts a `server` param that is
-    # responsible for having established the bi-directional
-    # communication channel. ::new uses the existing (sane) default of
-    # setting up the TCP channel for the user.
-    #
-    def self.new(host, port, options = {} , &callback)
-      server  = Celluloid::IO::TCPServer.new(host, port)
-      backlog = options.fetch(:backlog, DEFAULT_BACKLOG)
-
-      # prevent TCP packets from being buffered
-      server.setsockopt(Socket::IPPROTO_TCP, Socket::TCP_NODELAY, 1)
-      server.listen(backlog)
-
-      self._new(server, options, &callback)
-    end
-
-    # Create a Reel HTTP server over a UNIX socket.
-    #
-    # @param [String] socket_path path to the UNIX socket
-    # @option options [true] spy on the request
-    #
-    def self.unix(socket_path, options = {}, &callback)
-      server = Celluloid::IO::UNIXServer.new(socket_path)
-
-      self._new(server, options, &callback)
-    end
-
-    def initialize(server, options = {}, &callback)
+    def initialize(server, options={}, &callback)
       @spy      = STDOUT if options[:spy]
-      @server   = server
+      @options  = options
       @callback = callback
+      @server   = server
 
+      @server.listen(options.fetch(:backlog, DEFAULT_BACKLOG))
+
       async.run
-   end
-
+    end
 
     def shutdown
       @server.close if @server

lib/reel/server/http.rb

@@ -0,0 +1,25 @@
+module Reel
+  class HTTPServer < Server
+
+    execute_block_on_receiver :initialize
+
+    # Create a new Reel HTTPS server
+    #
+    # @param [String] host address to bind to
+    # @param [Fixnum] port to bind to
+    # @option options [Fixnum] backlog of requests to accept
+    #
+    # @return [Reel::HTTPServer] Reel HTTP server actor
+    def initialize(host, port, options={}, &callback)
+      optimize_socket server = Celluloid::IO::TCPServer.new(host, port)
+      options.merge!({ :host => host, :port => port })
+      super(server, options, &callback)
+    end
+
+    def shutdown
+      deoptimize_socket @server
+      super
+    end
+
+  end
+end

lib/reel/ssl_server.rb → lib/reel/server/ssl.rb

@@ -11,7 +11,8 @@ class SSLServer < Server
     # @option options [String] :key  the server's SSL key
     #
     # @return [Reel::SSLServer] Reel HTTPS server actor
-    def initialize(server, options = {}, &callback)
+    def initialize(host, port, options={}, &callback)
+
       # Ideally we can encapsulate this rather than making Ruby OpenSSL a
       # mandatory part of the Reel API. It would be nice to support
       # alternatives (e.g. Puma's MiniSSL)
@@ -31,16 +32,23 @@ def initialize(server, options = {}, &callback)
         else                                     OpenSSL::SSL::VERIFY_NONE
       end
 
-      # wrap an SSLServer around the Reel::Server we've been given
-      ssl_server = Celluloid::IO::SSLServer.new(server, ssl_context)
+      optimize_socket @tcpserver = Celluloid::IO::TCPServer.new(host, port)
+
+      server = Celluloid::IO::SSLServer.new(@tcpserver, ssl_context)
+      options.merge!({ :host => host, :port => port })
+
+      super(server, options, &callback)
+    end
 
-      super(ssl_server, options, &callback)
+    def shutdown
+      deoptimize_socket @tcpserver
+      super
     end
 
     def run
       loop do
         begin
-          socket = @server.accept
+          socket = @handler.accept
         rescue OpenSSL::SSL::SSLError => ex
           Logger.warn "Error accepting SSLSocket: #{ex.class}: #{ex.to_s}"
           retry

lib/reel/server/unix.rb

@@ -0,0 +1,19 @@
+module Reel
+  class UNIXServer < Server
+
+    execute_block_on_receiver :initialize
+
+    # Create a new Reel HTTPS server
+    #
+    # @option options [String] socket path to bind to
+    # @option options [Fixnum] backlog of requests to accept
+    #
+    # @return [Reel::UNIXServer] Reel UNIX server actor
+    def initialize(socket_path, options={}, &callback)
+    	server = Celluloid::IO::UNIXServer.new(socket_path)
+    	options[:socket_path] = socket_path
+      super(server, options, &callback)
+    end
+
+  end
+end

spec/spec_helper.rb

@@ -18,7 +18,7 @@ def example_path; "/example"; end
 def example_url;  "http://#{example_addr}:#{example_port}#{example_path}"; end
 
 def with_reel(handler)
-  server = Reel::Server.new(example_addr, example_port, &handler)
+  server = Reel::HTTPServer.new(example_addr, example_port, &handler)
   yield server
 ensure
   server.terminate if server && server.alive?