crap_server 0.0.2.2 → 0.0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 636e155531fe01738c575fc3d23dcd24557cd866
-  data.tar.gz: eb2b425befbd907828b6bdf55d1981643ef4f05d
+  metadata.gz: 3b7a2133b068b88f831896a41664b94448243b84
+  data.tar.gz: 49f6bebeaf9bdb5b51e33a39053630bc47068b40
 SHA512:
-  metadata.gz: 07230fa972fdf9f4b9fc5cf10043a0a4593fee1811012d9f1d93785dd585b82eb03bf02d7b225478bfb3b553286bfac0b54438ceb2f71f4effffb61d81e5c3fc
-  data.tar.gz: a3e470a6d2e4c3043b2c872da4e8cbfca3166e28f7795c8008d4cb50bf67b4ea6a8514e9b184c5e704cb534c02f2d4d2bb89fba4517daf008532ca938be50add
+  metadata.gz: 9bb7f5661dd2b9b51d96abf188a4038a275ae77a3ff13d4315b6c0ac03c616354bbc91293f8a65df6f2157c01616bc4432fbf1d841143cd7286e8163f3577414
+  data.tar.gz: 694265fae58d630a42b6b973014590fe1f3ec66e29b300a42f2919d9691b6e987154878e08b5ac6bd980032d38ccdc6358d4614bab3663606c4cf2cb86ce12e3

data/README.md

@@ -3,6 +3,7 @@
 [![Code Climate](https://codeclimate.com/github/anga/crap_server/badges/gpa.svg)](https://codeclimate.com/github/anga/crap_server)
 
 Really thin and non intuitive ruby server. Made to be fast and ready for really heavy servers (not only http server).
+Use Preforking and Evented pattern.
 
 # Another one?
 
@@ -35,14 +36,6 @@ Or install it yourself as:
         end
     end
 
-## Configuring the app
-
-    CrapServer::Application.configure do |config|
-        config.port = 80
-        config.read_method = :partial
-        config.read_buffer_size = 1024 # 1K
-    end
-
 See all available options in lib/crap_server/configure.rb
 
 # Running our application
@@ -51,7 +44,7 @@ ruby my_app.rb
 
 # Production ready?
 
-No. At the moment it's only a thin server that abstract you from TCP sockets works.
+No. Use it under your own risk. Right now, the interface can change.
 
 ## Contributing
 

data/lib/crap_server/application.rb

@@ -24,7 +24,6 @@ module CrapServer
 
       # Main method. This setup all the connections and make the logic of the app
       def run!(&block)
-
         begin
           # Bup the maximum opened file to the maximum allowed by the system
           Process.setrlimit(:NOFILE, Process.getrlimit(:NOFILE)[1])
@@ -40,11 +39,12 @@ module CrapServer
           logger.debug "Maximum number of allowed connections: #{Process.getrlimit(:NOFILE)[1]}" # Same as maximum of opened files
           logger.info ''
 
-          # The main loop. Listening IPv4 and IPv6 connections
-          Socket.accept_loop([socket_ipv4, socket_ipv6]) do |remote_socket, address_info|
-            connection_loop(remote_socket, address_info, &block)
-          end
+          # Prefork and handle the connections in each process.
+          forker = CrapServer::Forker.new([socket_ipv4, socket_ipv6])
+          # Run loop. (basically, waiting until Ctrl+C)
+          forker.run &block
 
+          # NOTE: I think this line never will be executed
           close_connections
 
         # If any kind of error happens, we MUST close the sockets
@@ -61,38 +61,6 @@ module CrapServer
       end
 
       protected
-      def connection_loop(remote_socket, addres_info, &block)
-          # Work with the connection...
-          if we_should_read?
-            reader = CrapServer::Helpers::SocketReader.new(remote_socket, config.method)
-            reader.address = addres_info
-            reader.config = config
-            reader.on_message(&block)
-          else
-            begin
-              if block.parameters == 1
-                block.call(remote_socket)
-              else
-                block.call(remote_socket, addres_info)
-              end
-                # If we get out of data to read (but still having an opened connection), we wait for new data.
-            rescue IO::WaitReadable
-              # This, prevent to execute so many retry and block the code until a new bunch of data gets available
-              IO.select([remote_socket])
-              # Yay!, we have more data. Now we can continue!
-              retry
-            end
-          end
-          # ...
-
-        # Close the connection
-        remote_socket.close if config.auto_close_connection
-      end
-
-      # Return true or false if the read process is done by the server.
-      def we_should_read?
-        not config.manual_read
-      end
 
       # Open TCP connection (IPv4 and IPv6)
       def open_connections
@@ -107,14 +75,14 @@ module CrapServer
         # If any kind of error happens, we MUST close the sockets
         if socket_ipv4
           # Shuts down communication on all copies of the connection.
-          socket_ipv4.shutdown
-          socket_ipv4.close
+          # socket_ipv4.shutdown
+          # socket_ipv4.close
         end
 
         if socket_ipv6
           # Shuts down communication on all copies of the connection.
-          socket_ipv6.shutdown
-          socket_ipv6.close
+          # socket_ipv6.shutdown
+          # socket_ipv6.close
         end
         # TODO: Close all opened sockets connections from other threads and processes
       end
@@ -137,6 +105,7 @@ module CrapServer
         # Tell to the Kernel that is ok to rebind the port if is in TIME_WAIT state (after close the connection
         # and the Kernel wait for client acknowledgement)
         socket_ipv6.setsockopt(:SOCKET, :REUSEADDR, true)
+
         @socket6 = socket_ipv6
       end
 
@@ -158,6 +127,7 @@ module CrapServer
         # Tell to the Kernel that is ok to rebind the port if is in TIME_WAIT state (after close the connection
         # and the Kernel wait for client acknowledgement)
         socket_ipv4.setsockopt(:SOCKET, :REUSEADDR, true)
+
         @socket4 = socket_ipv4
       end
 

data/lib/crap_server/configure.rb

@@ -22,6 +22,7 @@ module CrapServer
     attr_accessor :method
     # Set to false if you want to manage the close of the connection.
     # Note that this require manual_read set to true.
+    # DEPERCATED
     attr_accessor :auto_close_connection
     # The file to use as log
     attr_accessor :log_file

data/lib/crap_server/connection_handler.rb

@@ -0,0 +1,158 @@
+module CrapServer
+  class ConnectionHandler
+
+    def initialize(sockets)
+      @sockets = sockets
+      @sockets.each do |io|
+        add_to_read io
+      end
+    end
+
+    def add_to_write(io)
+      @to_write ||= {}
+      @to_write[io.fileno] = io
+    end
+
+    def to_write
+      (@to_write ||= {}).values
+    end
+
+    def remove_to_write(io)
+      @to_write.delete io.fileno
+      @buffer.delete io.fileno
+    end
+
+    def buffer(io)
+      @buffer ||= {}
+      @buffer[io.fileno]
+    end
+
+    def set_buffer(io, string)
+      @buffer ||= {}
+      @buffer[io.fileno] = string
+    end
+
+    def to_read
+      (@to_read ||= {}).values
+    end
+
+    def add_to_read(io)
+      @to_read ||= {}
+      @to_read[io.fileno] = io
+    end
+
+    def remove_to_read(io)
+      @to_read.delete io.fileno
+      @address.delete io.fileno
+    end
+
+    def address(io)
+      @address ||= {}
+      @address[io.fileno]
+    end
+
+    def set_address(io, addrs)
+      @address ||= {}
+      @address[io.fileno] = addrs
+    end
+
+    def read_buffer(io)
+      @rbuffer ||= {}
+      @rbuffer[io.fileno]
+    end
+
+    def add_read_buffer(io, string)
+      @rbuffer ||= {}
+      @rbuffer[io.fileno] ||= ''
+      @rbuffer[io.fileno] << string
+    end
+
+    def set_close_after_write(io)
+      @closeaw ||= {}
+      @closeaw[io.fileno] = true
+    end
+
+    def close_after_write(io)
+      @closeaw ||= {}
+      @closeaw[io.fileno]
+    end
+
+    def close(io)
+      remove_to_read io
+      remove_to_write io
+      @closeaw.delete io.fileno
+      io.close
+    end
+
+    def handle(&block)
+      # The main loop. Listening IPv4 and IPv6 connections
+      accept_loop do |data, remote_socket, address_info|
+        instance = CrapServer::ConnectionInstance.new
+        instance.socket = remote_socket
+        instance.config = config
+        instance.address = address_info
+        instance.send(:method=, config.method)
+        instance.handler = self
+        instance.run data, &block
+      end
+    end
+
+    protected
+
+    # Evented loop (Reactor pattern)
+    def accept_loop
+      loop {
+        @readables,  @writables = IO.select(to_read, to_write)
+
+        @readables.each do |socket|
+          if @sockets.include? socket
+            io, addr = socket.accept
+            set_address io, addr
+            set_close_after_write io if config.auto_close_connection
+            # Disabling Nagle's algorithm. Is fucking slow :P
+            io.setsockopt(Socket::IPPROTO_TCP, Socket::TCP_NODELAY, 1)
+            # We add him to the read queue
+            add_to_read io
+          else
+            begin
+              _, data = socket, socket.read_nonblock(config.read_buffer_size)
+              yield data, socket, address(socket)
+            rescue Errno::EAGAIN
+            rescue EOFError
+              remove_to_read socket
+            end
+          end
+        end
+
+        @writables.each do |socket|
+          begin
+            string = buffer socket
+            bytes = socket.write_nonblock string
+            string.slice! 0, bytes
+            if string.empty?
+              # If we don't have more data to send to the client
+              if close_after_write socket
+                close socket
+              else
+                remove_to_write socket
+              end
+            else
+              set_buffer socket, string
+              remove_to_read socket
+            end
+          # If the client close the connection, we remove is from read and from write
+          rescue Errno::ECONNRESET, Errno::EPIPE
+            if close_after_write socket
+              close socket
+            end
+          end
+        end
+      }
+    end
+
+    protected
+    def config
+      CrapServer::Application.send(:config)
+    end
+  end
+end

data/lib/crap_server/connection_instance.rb

@@ -6,57 +6,43 @@ module CrapServer
     attr_accessor :address
     attr_accessor :config
     attr_accessor :method
+    attr_accessor :handler
     def initialize; end
 
     # This method execute the block sent to run! method
-    def run(&block)
+    def run(data, &block)
       # Undefine the last definition if was defined
       undef :call if self.respond_to? :call
       # Define the new method to bind the block with this class.
       self.class.send :define_method, :call, &block
       # Running the code depending of the number of args
       if block.parameters.size == 1
-        self.call(read_data)
+        self.call(data)
       elsif block.parameters.size == 2
-        self.call(read_data, socket)
+        self.call(data, socket)
       else
-        self.call(read_data, socket, address)
+        self.call(data, socket, address)
       end
+      @socket.flush
     end
 
     # Write to the client the given string
     def write(string)
-      begin
-        if @method == :normal or @method == :partial
-          @socket.write(string)
-        elsif  @method == :non_blocking
-          @socket.write_nonblock(string)
-        end
-      rescue IO::WaitWritable, Errno::EINTR
-        IO.select(nil, [@socket], nil, config.timeout)
-      end
+      @handler.add_to_write @socket
+      @handler.set_buffer @socket, string
+    end
+
+    def close_after_write
+      @handler.set_close_after_write @socket
+    end
+
+    def close
+      @handler.close @socket
     end
 
     # Give access to logger class to the user
     def logger
       @config.logger
     end
-    protected
-    # Read the data from the socket
-    def read_data
-      begin
-        # Read the data from the socket
-        if @method == :normal
-          @socket.read(config.read_buffer_size)
-        elsif @method == :partial
-          @socket.readpartial(config.read_buffer_size)
-        elsif  @method == :non_blocking
-          @socket.read_nonblock(config.read_buffer_size)
-        end
-      rescue Errno::EAGAIN
-        IO.select([connection],nil,nil, config.timeout)
-        retry
-      end
-    end
   end
 end

data/lib/crap_server/forker.rb

@@ -0,0 +1,108 @@
+module CrapServer
+  # Handle preforking task.
+  # Will spawn 1 process per core.
+  class Forker
+    def initialize(sockets)
+      @sockets = sockets
+    end
+
+    # Initialize
+    def run(&block)
+      begin
+        @block_proc = block
+        child_pids = []
+        processor_count.times do
+          child_pids << spawn_child
+        end
+
+        # We take care of our children. If someone kill one, me made another one.
+        # PS: Is a hard work :P
+        loop do
+          pid = Process.wait
+          child_pids.delete(pid)
+          child_pids << spawn_child
+        end
+      # If someone kill us, we kill our children. Yes, is sad, but we must do it :'(
+      rescue Interrupt
+        child_pids.each do |cpid|
+          begin
+            # We send Ctrl+C to the process
+            Process.kill(:INT, cpid)
+          rescue Errno::ESRCH
+          end
+        end
+        @sockets.each do |socket|
+          # Shuts down communication on all copies of the connection.
+          socket.shutdown
+          socket.close
+        end
+
+      end
+    end
+
+    protected
+
+    def spawn_child
+      fork do
+        begin
+          handler = CrapServer::ConnectionHandler.new @sockets
+          handler.handle &@block_proc
+        rescue Interrupt
+        end
+      end
+    end
+
+    # Extracted from https://github.com/grosser/parallel/blob/master/lib/parallel.rb
+    # Number of processors seen by the OS and used for process scheduling.
+    #
+    # * AIX: /usr/sbin/pmcycles (AIX 5+), /usr/sbin/lsdev
+    # * BSD: /sbin/sysctl
+    # * Cygwin: /proc/cpuinfo
+    # * Darwin: /usr/bin/hwprefs, /usr/sbin/sysctl
+    # * HP-UX: /usr/sbin/ioscan
+    # * IRIX: /usr/sbin/sysconf
+    # * Linux: /proc/cpuinfo
+    # * Minix 3+: /proc/cpuinfo
+    # * Solaris: /usr/sbin/psrinfo
+    # * Tru64 UNIX: /usr/sbin/psrinfo
+    # * UnixWare: /usr/sbin/psrinfo
+    #
+    def processor_count
+      @processor_count ||= begin
+        os_name = RbConfig::CONFIG["target_os"]
+        if os_name =~ /mingw|mswin/
+          require 'win32ole'
+          result = WIN32OLE.connect("winmgmts://").ExecQuery(
+              "select NumberOfLogicalProcessors from Win32_Processor")
+          result.to_enum.collect(&:NumberOfLogicalProcessors).reduce(:+)
+        elsif File.readable?("/proc/cpuinfo")
+          IO.read("/proc/cpuinfo").scan(/^processor/).size
+        elsif File.executable?("/usr/bin/hwprefs")
+          IO.popen("/usr/bin/hwprefs thread_count").read.to_i
+        elsif File.executable?("/usr/sbin/psrinfo")
+          IO.popen("/usr/sbin/psrinfo").read.scan(/^.*on-*line/).size
+        elsif File.executable?("/usr/sbin/ioscan")
+          IO.popen("/usr/sbin/ioscan -kC processor") do |out|
+            out.read.scan(/^.*processor/).size
+          end
+        elsif File.executable?("/usr/sbin/pmcycles")
+          IO.popen("/usr/sbin/pmcycles -m").read.count("\n")
+        elsif File.executable?("/usr/sbin/lsdev")
+          IO.popen("/usr/sbin/lsdev -Cc processor -S 1").read.count("\n")
+        elsif File.executable?("/usr/sbin/sysconf") and os_name =~ /irix/i
+          IO.popen("/usr/sbin/sysconf NPROC_ONLN").read.to_i
+        elsif File.executable?("/usr/sbin/sysctl")
+          IO.popen("/usr/sbin/sysctl -n hw.ncpu").read.to_i
+        elsif File.executable?("/sbin/sysctl")
+          IO.popen("/sbin/sysctl -n hw.ncpu").read.to_i
+        else
+          $stderr.puts "Unknown platform: " + RbConfig::CONFIG["target_os"]
+          $stderr.puts "Assuming 1 processor."
+          1
+        end
+      end
+    end
+
+
+  end
+end

data/lib/crap_server/version.rb

@@ -1,3 +1,3 @@
 module CrapServer
-  VERSION = '0.0.2.2'
+  VERSION = '0.0.3.0'
 end

data/lib/crap_server.rb

@@ -1,7 +1,8 @@
 require 'crap_server/version'
 require 'crap_server/configure'
+require 'crap_server/forker'
+require 'crap_server/connection_handler'
 require 'crap_server/connection_instance'
-require 'crap_server/helpers/socket_reader'
 require 'crap_server/application'
 module CrapServer
   # Your code goes here...

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: crap_server
 version: !ruby/object:Gem::Version
-  version: 0.0.2.2
+  version: 0.0.3.0
 platform: ruby
 authors:
 - Andres Jose Borek
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-08-05 00:00:00.000000000 Z
+date: 2014-08-06 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -55,8 +55,9 @@ files:
 - lib/crap_server.rb
 - lib/crap_server/application.rb
 - lib/crap_server/configure.rb
+- lib/crap_server/connection_handler.rb
 - lib/crap_server/connection_instance.rb
-- lib/crap_server/helpers/socket_reader.rb
+- lib/crap_server/forker.rb
 - lib/crap_server/version.rb
 - spec/application_spec.rb
 - spec/spec_helper.rb

data/lib/crap_server/helpers/socket_reader.rb

@@ -1,35 +0,0 @@
-module CrapServer
-  module Helpers
-    # Makes easier work with sockets and read.
-    class SocketReader
-      attr_accessor :method
-      attr_accessor :socket
-      attr_accessor :address
-      attr_accessor :config
-      def initialize(socket_, method_=:partial)
-        @socket = socket_
-        @method = method_
-      end
-
-      def on_message(&block)
-        begin
-            instance = CrapServer::ConnectionInstance.new
-            instance.socket = socket
-            instance.config = config
-            instance.address = address
-            instance.send(:method=, method)
-            instance.run &block
-          # If we get out of data to read (but still having an opened connection), we wait for new data.
-        rescue IO::WaitReadable
-          # This, prevent to execute so many retry and block the code until a new bunch of data gets available
-          IO.select([@socket])
-          # Yay!, we have more data. Now we can continue!
-          retry
-        # When we use non_blocking method, and the client close the connection we will get EOF after that moment
-        # We do nothing special in that moment
-        rescue EOFError
-        end
-      end
-    end
-  end
-end