dat-tcp 0.4.0 → 0.5.0

data/Gemfile

@@ -3,4 +3,4 @@ source "https://rubygems.org"
 gemspec
 
 gem 'rake'
-gem 'pry'
+gem 'pry', "~> 0.9.0"

data/Rakefile

@@ -1,2 +1 @@
 require "bundler/gem_tasks"
-require "bench/tasks"

data/dat-tcp.gemspec

@@ -12,14 +12,14 @@ Gem::Specification.new do |gem|
                       " designed for use as a base for application servers."
   gem.summary       = "A generic threaded TCP server API"
   gem.homepage      = "https://github.com/redding/dat-tcp"
+  gem.license       = 'MIT'
 
   gem.files         = `git ls-files -- lib/* Gemfile Rakefile *.gemspec`.split($/)
   gem.executables   = gem.files.grep(%r{^bin/}).map{ |f| File.basename(f) }
   gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
   gem.require_paths = ["lib"]
 
-  gem.add_dependency("dat-worker-pool", ["~> 0.1"])
+  gem.add_dependency("dat-worker-pool", ["~> 0.3"])
 
-  gem.add_development_dependency('assert',        ['~> 2.0'])
-  gem.add_development_dependency('assert-mocha',  ['~> 1.0'])
+  gem.add_development_dependency('assert', ['~> 2.11'])
 end

data/lib/dat-tcp.rb

@@ -1,5 +1,4 @@
 require 'dat-worker-pool'
-require 'ostruct'
 require 'socket'
 require 'thread'
 
@@ -8,86 +7,27 @@ require 'dat-tcp/logger'
 
 module DatTCP
 
-  module Server
+  class Server
 
     attr_reader :logger
-
-    def initialize(config = nil)
-      config = OpenStruct.new(config || {})
-      @backlog_size     = config.backlog_size     || 1024
-      @debug            = config.debug            || false
-      @min_workers      = config.min_workers      || 2
-      @max_workers      = config.max_workers      || 4
-      @ready_timeout    = config.ready_timeout    || 1
-      @shutdown_timeout = config.shutdown_timeout || 15
+    private :logger
+
+    def initialize(config = nil, &serve_proc)
+      config ||= {}
+      @backlog_size     = config[:backlog_size]     || 1024
+      @debug            = config[:debug]            || false
+      @min_workers      = config[:min_workers]      || 2
+      @max_workers      = config[:max_workers]      || 4
+      @shutdown_timeout = config[:shutdown_timeout] || 15
+      @signal_reader, @signal_writer = IO.pipe
+      @serve_proc = serve_proc || raise(ArgumentError, "no block given")
 
       @logger = DatTCP::Logger.new(@debug)
 
-      check_configuration
-
       @tcp_server       = nil
       @work_loop_thread = nil
       @worker_pool      = nil
-      set_state :stop
-    end
-
-    # Socket Options:
-    # * SOL_SOCKET   - specifies the protocol layer the option applies to.
-    #                  SOL_SOCKET is basic socket options (as opposed to
-    #                  something like IPPROTO_TCP for TCP socket options).
-    # * SO_REUSEADDR - indicates that the rules used in validating addresses
-    #                  supplied in a bind(2) call should allow reuse of local
-    #                  addresses. This will allow us to re-bind to a port if we
-    #                  were shutdown and started right away. This will still
-    #                  throw an "address in use" if a socket is active on the
-    #                  port.
-
-    def listen(*args)
-      build_server_method = if args.size == 2
-        :new
-      elsif args.size == 1
-        :for_fd
-      else
-        raise InvalidListenArgsError.new
-      end
-      set_state :listen
-      run_hook 'on_listen'
-      @tcp_server = TCPServer.send(build_server_method, *args)
-
-      @tcp_server.setsockopt(Socket::SOL_SOCKET, Socket::SO_REUSEADDR, true)
-      run_hook 'configure_tcp_server', @tcp_server
-
-      @tcp_server.listen(@backlog_size)
-    end
-
-    def run(client_file_descriptors = nil)
-      raise NotListeningError.new if !self.listening?
-      set_state :run
-      run_hook 'on_run'
-      @work_loop_thread = Thread.new{ work_loop(client_file_descriptors) }
-    end
-
-    def pause(wait = true)
-      set_state :pause
-      run_hook 'on_pause'
-      wait_for_shutdown if wait
-    end
-
-    def stop(wait = true)
-      set_state :stop
-      run_hook 'on_stop'
-      wait_for_shutdown if wait
-    end
-
-    def halt(wait = true)
-      set_state :halt
-      run_hook 'on_halt'
-      wait_for_shutdown if wait
-    end
-
-    def stop_listening
-      @tcp_server.close rescue false
-      @tcp_server = nil
+      @signal = Signal.new(:stop)
     end
 
     def ip
@@ -111,103 +51,107 @@ module DatTCP
     end
 
     def running?
-      !!@work_loop_thread
-    end
-
-    def serve(socket)
-      self.serve!(socket)
-    ensure
-      socket.close rescue false
-    end
-
-    # This method should be overwritten to handle new connections
-    def serve!(socket)
+      !!(@work_loop_thread && @work_loop_thread.alive?)
     end
 
-    # Hooks
-
-    def on_listen
+    def listen(*args)
+      @signal.set :listen
+      @tcp_server = TCPServer.build(*args)
+      raise ArgumentError, "takes ip and port or file descriptor" if !@tcp_server
+      yield @tcp_server if block_given?
+      @tcp_server.listen(@backlog_size)
     end
 
-    def configure_tcp_server(tcp_server)
+    def stop_listen
+      @tcp_server.close rescue false
+      @tcp_server = nil
     end
 
-    def on_run
+    def start(client_file_descriptors = nil)
+      raise NotListeningError.new unless listening?
+      @signal.set :start
+      @work_loop_thread = Thread.new{ work_loop(client_file_descriptors) }
     end
 
-    def on_pause
+    def pause(wait = false)
+      @signal_writer.write_nonblock('p')
+      wait_for_shutdown if wait
     end
 
-    def on_stop
+    def stop(wait = false)
+      @signal_writer.write_nonblock('s')
+      wait_for_shutdown if wait
     end
 
-    def on_halt
+    def halt(wait = false)
+      @signal_writer.write_nonblock('h')
+      wait_for_shutdown if wait
     end
 
     def inspect
       reference = '0x0%x' % (self.object_id << 1)
-      "#<#{self.class}:#{reference}".tap do |inspect_str|
-        inspect_str << " @state=#{@state.inspect}"
-        if self.listening?
-          port, ip = @tcp_server.addr[1, 2]
-          inspect_str << " @ip=#{ip.inspect} @port=#{port.inspect}"
-        end
-        inspect_str << " @work_loop_status=#{@work_loop_thread.status.inspect}" if self.running?
-        inspect_str << ">"
+      "#<#{self.class}:#{reference}".tap do |s|
+        s << " @ip=#{ip.inspect} @port=#{port.inspect}"
+        s << " @work_loop_status=#{@work_loop_thread.status.inspect}" if running?
+        s << ">"
       end
     end
 
-    protected
+    private
+
+    def serve(socket)
+      @serve_proc.call(socket)
+    ensure
+      socket.close rescue false
+    end
 
     def work_loop(client_file_descriptors = nil)
-      self.logger.info "Starting work loop..."
-      pool_args = [ @min_workers, @max_workers, @debug ]
-      @worker_pool = DatWorkerPool.new(*pool_args){|socket| serve(socket) }
-      self.enqueue_file_descriptors(client_file_descriptors || [])
-      while @state.run?
-        @worker_pool.add_work self.accept_connection
+      logger.info "Starting work loop..."
+      @worker_pool = DatWorkerPool.new(@min_workers, @max_workers) do |socket|
+        serve(socket)
       end
-      self.logger.info "Stopping work loop..."
-      shutdown_worker_pool if !@state.halt?
-    rescue Exception => exception
-      self.logger.error "Exception occurred, stopping server!"
-      self.logger.error "#{exception.class}: #{exception.message}"
-      self.logger.error exception.backtrace.join("\n")
+      add_client_sockets_from_fds client_file_descriptors
+      process_inputs while @signal.start?
+      logger.info "Stopping work loop..."
+      shutdown_worker_pool unless @signal.halt?
+    rescue StandardError => exception
+      logger.error "Exception occurred, stopping server!"
+      logger.error "#{exception.class}: #{exception.message}"
+      logger.error exception.backtrace.join("\n")
     ensure
-      close_connection if !@state.pause?
+      unless @signal.pause?
+        logger.info "Closing TCP server connection"
+        stop_listen
+      end
       clear_thread
-      self.logger.info "Stopped work loop"
+      logger.info "Stopped work loop"
     end
 
-    def enqueue_file_descriptors(file_descriptors)
-      file_descriptors.each do |file_descriptor|
+    def add_client_sockets_from_fds(file_descriptors)
+      (file_descriptors || []).each do |file_descriptor|
         @worker_pool.add_work TCPSocket.for_fd(file_descriptor)
       end
     end
 
-    # An accept-loop waiting for new connections. Will wait for a connection
-    # (up to `ready_timeout`) and accept it. `IO.select` with the timeout
-    # allows the server to be responsive to shutdowns.
+    def process_inputs
+      ready_inputs, _, _ = IO.select([ @tcp_server, @signal_reader ])
+      accept_connection if ready_inputs.include?(@tcp_server)
+      process_signal    if ready_inputs.include?(@signal_reader)
+    end
+
     def accept_connection
-      while @state.run?
-        return @tcp_server.accept if self.connection_ready?
-      end
+      @worker_pool.add_work @tcp_server.accept
     end
 
-    def connection_ready?
-      !!IO.select([ @tcp_server ], nil, nil, @ready_timeout)
+    def process_signal
+      @signal.send @signal_reader.read_nonblock(1)
     end
 
     def shutdown_worker_pool
-      self.logger.info "Shutting down worker pool, letting it finish..."
+      logger.info "Shutting down worker pool"
       @worker_pool.shutdown(@shutdown_timeout)
     end
 
-    def close_connection
-      self.logger.info "Closing TCP server connection..."
-      self.stop_listening
-    end
-
     def clear_thread
       @work_loop_thread = nil
     end
@@ -216,50 +160,81 @@ module DatTCP
       @work_loop_thread.join if @work_loop_thread
     end
 
-    def check_configuration
-      if @min_workers > @max_workers
-        self.logger.warn "The minimum number of workers (#{@min_workers}) " \
-                         "is greater than " \
-                         "the maximum number of workers (#{@max_workers})."
+    class Signal
+      def initialize(value)
+        @value = value
+        @mutex = Mutex.new
       end
-    end
 
-    def run_hook(method, *args)
-      self.send(method, *args)
-    end
+      def s; set :stop;  end
+      def h; set :halt;  end
+      def p; set :pause; end
 
-    def set_state(name)
-      @state = State.new(name)
-    end
+      def set(value)
+        @mutex.synchronize{ @value = value }
+      end
 
-    class State < String
+      def listen?
+        @mutex.synchronize{ @value == :listen }
+      end
 
-      def initialize(value)
-        super value.to_s
+      def start?
+        @mutex.synchronize{ @value == :start }
       end
 
-      [ :listen, :run, :stop, :halt, :pause ].each do |name|
-        define_method("#{name}?"){ self.to_sym == name }
+      def pause?
+        @mutex.synchronize{ @value == :pause }
       end
 
+      def stop?
+        @mutex.synchronize{ @value == :stop }
+      end
+
+      def halt?
+        @mutex.synchronize{ @value == :halt }
+      end
     end
 
-  end
+    module TCPServer
+      def self.build(*args)
+        case args.size
+        when 2
+          self.new(*args)
+        when 1
+          self.for_fd(*args)
+        end
+      end
 
-  class InvalidListenArgsError < ArgumentError
+      def self.new(ip, port)
+        configure(::TCPServer.new(ip, port))
+      end
 
-    def initialize
-      super "invalid arguments, must be either a file descriptor or an ip and port"
+      def self.for_fd(file_descriptor)
+        configure(::TCPServer.for_fd(file_descriptor))
+      end
+
+      # `setsockopt` values:
+      # * SOL_SOCKET   - specifies the protocol layer the option applies to.
+      #                  SOL_SOCKET is basic socket options (as opposed to
+      #                  something like IPPROTO_TCP for TCP socket options).
+      # * SO_REUSEADDR - indicates that the rules used in validating addresses
+      #                  supplied in a bind(2) call should allow reuse of local
+      #                  addresses. This will allow us to re-bind to a port if
+      #                  we were shutdown and started right away. This will
+      #                  still throw an "address in use" if a socket is active
+      #                  on the port.
+      def self.configure(tcp_server)
+        tcp_server.setsockopt(Socket::SOL_SOCKET, Socket::SO_REUSEADDR, true)
+        tcp_server
+      end
     end
 
   end
 
   class NotListeningError < RuntimeError
-
     def initialize
-      super "`listen` must be called before calling `run`"
+      super "server isn't listening, call `listen` first"
     end
-
   end
 
 end

data/lib/dat-tcp/version.rb

@@ -1,3 +1,3 @@
 module DatTCP
-  VERSION = "0.4.0"
+  VERSION = "0.5.0"
 end

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: dat-tcp
 version: !ruby/object:Gem::Version 
-  hash: 15
+  hash: 11
   prerelease: 
   segments: 
   - 0
-  - 4
+  - 5
   - 0
-  version: 0.4.0
+  version: 0.5.0
 platform: ruby
 authors: 
 - Collin Redding
@@ -16,53 +16,38 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2013-07-15 00:00:00 Z
+date: 2014-06-17 00:00:00 Z
 dependencies: 
 - !ruby/object:Gem::Dependency 
-  prerelease: false
-  version_requirements: &id001 !ruby/object:Gem::Requirement 
+  requirement: &id001 !ruby/object:Gem::Requirement 
     none: false
     requirements: 
     - - ~>
       - !ruby/object:Gem::Version 
-        hash: 9
+        hash: 13
         segments: 
         - 0
-        - 1
-        version: "0.1"
-  requirement: *id001
-  name: dat-worker-pool
+        - 3
+        version: "0.3"
+  version_requirements: *id001
   type: :runtime
-- !ruby/object:Gem::Dependency 
+  name: dat-worker-pool
   prerelease: false
-  version_requirements: &id002 !ruby/object:Gem::Requirement 
+- !ruby/object:Gem::Dependency 
+  requirement: &id002 !ruby/object:Gem::Requirement 
     none: false
     requirements: 
     - - ~>
       - !ruby/object:Gem::Version 
-        hash: 3
+        hash: 21
         segments: 
         - 2
-        - 0
-        version: "2.0"
-  requirement: *id002
-  name: assert
+        - 11
+        version: "2.11"
+  version_requirements: *id002
   type: :development
-- !ruby/object:Gem::Dependency 
+  name: assert
   prerelease: false
-  version_requirements: &id003 !ruby/object:Gem::Requirement 
-    none: false
-    requirements: 
-    - - ~>
-      - !ruby/object:Gem::Version 
-        hash: 15
-        segments: 
-        - 1
-        - 0
-        version: "1.0"
-  requirement: *id003
-  name: assert-mocha
-  type: :development
 description: A generic threaded TCP server API.  It is designed for use as a base for application servers.
 email: 
 - collin.redding@me.com
@@ -81,8 +66,8 @@ files:
 - lib/dat-tcp/logger.rb
 - lib/dat-tcp/version.rb
 homepage: https://github.com/redding/dat-tcp
-licenses: []
-
+licenses: 
+- MIT
 post_install_message: 
 rdoc_options: []
 
@@ -109,7 +94,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
 requirements: []
 
 rubyforge_project: 
-rubygems_version: 1.8.15
+rubygems_version: 1.8.29
 signing_key: 
 specification_version: 3
 summary: A generic threaded TCP server API