dat-tcp 0.7.0 → 0.8.0

data/Gemfile

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

data/dat-tcp.gemspec

@@ -19,7 +19,8 @@ Gem::Specification.new do |gem|
   gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
   gem.require_paths = ["lib"]
 
-  gem.add_dependency("dat-worker-pool", ["~> 0.5"])
+  gem.add_dependency("dat-worker-pool", ["~> 0.6"])
 
-  gem.add_development_dependency('assert', ['~> 2.15'])
+  gem.add_development_dependency("assert", ["~> 2.15"])
+  gem.add_development_dependency("scmd",   ["~> 3.0"])
 end

data/lib/dat-tcp.rb

@@ -3,38 +3,44 @@ require 'socket'
 require 'thread'
 
 require 'dat-tcp/version'
-require 'dat-tcp/logger'
+require 'dat-tcp/worker'
 
 module DatTCP
 
   class Server
 
-    attr_reader :worker_start_procs, :worker_shutdown_procs
-    attr_reader :worker_sleep_procs, :worker_wakeup_procs
-    attr_reader :logger
-    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
+    DEFAULT_BACKLOG_SIZE     = 1024
+    DEFAULT_SHUTDOWN_TIMEOUT = 15
+    DEFAULT_NUM_WORKERS      = 2
+
+    SIGNAL = '.'.freeze
+
+    def initialize(worker_class, options = nil)
+      if !worker_class.kind_of?(Class) || !worker_class.include?(DatTCP::Worker)
+        raise ArgumentError, "worker class must include `#{DatTCP::Worker}`"
+      end
+
+      options ||= {}
+      @backlog_size     = options[:backlog_size]     || DEFAULT_BACKLOG_SIZE
+      @shutdown_timeout = options[:shutdown_timeout] || DEFAULT_SHUTDOWN_TIMEOUT
+
       @signal_reader, @signal_writer = IO.pipe
-      @serve_proc = serve_proc || raise(ArgumentError, "no block given")
 
-      @worker_start_procs    = []
-      @worker_shutdown_procs = []
-      @worker_sleep_procs    = []
-      @worker_wakeup_procs   = []
+      @logger_proxy = if options[:logger]
+        LoggerProxy.new(options[:logger])
+      else
+        NullLoggerProxy.new
+      end
 
-      @logger = DatTCP::Logger.new(@debug)
+      @worker_pool = DatWorkerPool.new(worker_class, {
+        :num_workers   => (options[:num_workers] || DEFAULT_NUM_WORKERS),
+        :logger        => options[:logger],
+        :worker_params => options[:worker_params]
+      })
 
-      @tcp_server       = nil
-      @work_loop_thread = nil
-      @worker_pool      = nil
-      @signal = Signal.new(:stop)
+      @tcp_server = nil
+      @thread     = nil
+      @state      = State.new(:stop)
     end
 
     def ip
@@ -50,7 +56,7 @@ module DatTCP
     end
 
     def client_file_descriptors
-      @worker_pool ? @worker_pool.work_items.map(&:fileno) : []
+      @worker_pool.work_items.map(&:fileno)
     end
 
     def listening?
@@ -58,11 +64,11 @@ module DatTCP
     end
 
     def running?
-      !!(@work_loop_thread && @work_loop_thread.alive?)
+      !!(@thread && @thread.alive?)
     end
 
     def listen(*args)
-      @signal.set :listen
+      @state.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?
@@ -74,159 +80,104 @@ module DatTCP
       @tcp_server = nil
     end
 
-    def start(client_file_descriptors = nil)
+    def start(passed_client_fds = nil)
       raise NotListeningError.new unless listening?
-      @signal.set :start
-      @work_loop_thread = Thread.new{ work_loop(client_file_descriptors) }
+      @state.set :run
+      @thread = Thread.new{ work_loop(passed_client_fds) }
     end
 
     def pause(wait = false)
-      @signal_writer.write_nonblock('p')
+      return unless self.running?
+      @state.set :pause
+      wakeup_thread
       wait_for_shutdown if wait
     end
 
     def stop(wait = false)
-      @signal_writer.write_nonblock('s')
+      return unless self.running?
+      @state.set :stop
+      wakeup_thread
       wait_for_shutdown if wait
     end
 
     def halt(wait = false)
-      @signal_writer.write_nonblock('h')
+      return unless self.running?
+      @state.set :halt
+      wakeup_thread
       wait_for_shutdown if wait
     end
 
-    def on_worker_start(&block);    @worker_start_procs << block;    end
-    def on_worker_shutdown(&block); @worker_shutdown_procs << block; end
-    def on_worker_sleep(&block);    @worker_sleep_procs << block;    end
-    def on_worker_wakeup(&block);   @worker_wakeup_procs << block;   end
-
     def inspect
       reference = '0x0%x' % (self.object_id << 1)
       "#<#{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
 
     private
 
-    def serve(socket)
-      @serve_proc.call(socket)
+    def work_loop(passed_client_fds)
+      setup(passed_client_fds)
+      accept_client_connections while @state.run?
+    rescue StandardError => exception
+      @state.set :stop
+      log{ "An error occurred while running the server, exiting" }
+      log{ "#{exception.class}: #{exception.message}" }
+      (exception.backtrace || []).each{ |l| log{ l } }
     ensure
-      socket.close rescue false
+      teardown
     end
 
-    def work_loop(client_file_descriptors = nil)
-      logger.info "Starting work loop..."
-      @worker_pool = build_worker_pool
-      add_client_sockets_from_fds client_file_descriptors
+    def setup(passed_client_fds)
       @worker_pool.start
-      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
-      unless @signal.pause?
-        logger.info "Closing TCP server connection"
-        stop_listen
+      (passed_client_fds || []).each do |fd|
+        @worker_pool.push TCPSocket.for_fd(fd)
       end
-      clear_thread
-      logger.info "Stopped work loop"
     end
 
-    def build_worker_pool
-      wp = DatWorkerPool.new(
-        @min_workers,
-        @max_workers
-      ){ |socket| serve(socket) }
+    def accept_client_connections
+      ready_inputs, _, _ = IO.select([@tcp_server, @signal_reader])
 
-      # add any configured callbacks
-      self.worker_start_procs.each do |cb|
-        wp.on_worker_start(&cb)
+      if ready_inputs.include?(@tcp_server)
+        @worker_pool.push @tcp_server.accept
       end
-      self.worker_shutdown_procs.each do |cb|
-        wp.on_worker_shutdown(&cb)
-      end
-      self.worker_sleep_procs.each do |cb|
-        wp.on_worker_sleep(&cb)
-      end
-      self.worker_wakeup_procs.each do |cb|
-        wp.on_worker_wakeup(&cb)
-      end
-
-      wp
-    end
 
-    def add_client_sockets_from_fds(file_descriptors)
-      (file_descriptors || []).each do |file_descriptor|
-        @worker_pool.add_work TCPSocket.for_fd(file_descriptor)
+      if ready_inputs.include?(@signal_reader)
+        @signal_reader.read_nonblock(SIGNAL.bytesize)
       end
     end
 
-    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
-      @worker_pool.add_work @tcp_server.accept
-    end
-
-    def process_signal
-      @signal.send @signal_reader.read_nonblock(1)
-    end
+    def teardown
+      unless @state.pause?
+        log{ "Stop listening for connections, closing TCP socket" }
+        self.stop_listen
+      end
 
-    def shutdown_worker_pool
-      logger.info "Shutting down worker pool"
-      @worker_pool.shutdown(@shutdown_timeout)
+      timeout = @state.halt? ? 0 : @shutdown_timeout
+      @worker_pool.shutdown(timeout)
+    ensure
+      @thread = nil
     end
 
-    def clear_thread
-      @work_loop_thread = nil
+    def wakeup_thread
+      @signal_writer.write_nonblock(SIGNAL)
     end
 
     def wait_for_shutdown
-      @work_loop_thread.join if @work_loop_thread
+      @thread.join if @thread
     end
 
-    class Signal
-      def initialize(value)
-        @value = value
-        @mutex = Mutex.new
-      end
-
-      def s; set :stop;  end
-      def h; set :halt;  end
-      def p; set :pause; end
-
-      def set(value)
-        @mutex.synchronize{ @value = value }
-      end
-
-      def listen?
-        @mutex.synchronize{ @value == :listen }
-      end
-
-      def start?
-        @mutex.synchronize{ @value == :start }
-      end
-
-      def pause?
-        @mutex.synchronize{ @value == :pause }
-      end
-
-      def stop?
-        @mutex.synchronize{ @value == :stop }
-      end
+    def log(&message_block)
+      @logger_proxy.log(&message_block)
+    end
 
-      def halt?
-        @mutex.synchronize{ @value == :halt }
-      end
+    class State < DatWorkerPool::LockedObject
+      def listen?; self.value == :listen; end
+      def run?;    self.value == :run;    end
+      def pause?;  self.value == :pause;  end
+      def stop?;   self.value == :stop;   end
+      def halt?;   self.value == :halt;   end
     end
 
     module TCPServer
@@ -263,6 +214,16 @@ module DatTCP
       end
     end
 
+    class LoggerProxy < Struct.new(:logger)
+      def log(&message_block)
+        self.logger.debug("[DTCP] #{message_block.call}")
+      end
+    end
+
+    class NullLoggerProxy
+      def log(&block); end
+    end
+
   end
 
   class NotListeningError < RuntimeError

data/lib/dat-tcp/server_spy.rb

@@ -1,45 +1,49 @@
-require 'dat-tcp/logger'
+require 'dat-tcp'
+require 'dat-tcp/worker'
 
 module DatTCP
 
   class ServerSpy
 
+    attr_reader :worker_class
+    attr_reader :options, :backlog_size, :shutdown_timeout
+    attr_reader :num_workers, :logger, :worker_params
     attr_reader :ip, :port, :file_descriptor
     attr_reader :client_file_descriptors
-    attr_reader :logger
-    attr_reader :worker_start_procs, :worker_shutdown_procs
-    attr_reader :worker_sleep_procs, :worker_wakeup_procs
     attr_reader :waiting_for_pause, :waiting_for_stop, :waiting_for_halt
     attr_accessor :listen_called, :start_called
     attr_accessor :stop_listen_called, :pause_called
     attr_accessor :stop_called, :halt_called
 
-    attr_accessor :serve_proc
+    def initialize(worker_class, options = nil)
+      @worker_class = worker_class
+      if !@worker_class.kind_of?(Class) || !@worker_class.include?(DatTCP::Worker)
+        raise ArgumentError, "worker class must include `#{DatTCP::Worker}`"
+      end
 
-    def initialize
-      @ip = nil
-      @port = nil
-      @file_descriptor = nil
+      server_ns = DatTCP::Server
+      @options          = options || {}
+      @backlog_size     = @options[:backlog_size]     || server_ns::DEFAULT_BACKLOG_SIZE
+      @shutdown_timeout = @options[:shutdown_timeout] || server_ns::DEFAULT_SHUTDOWN_TIMEOUT
+      @num_workers      = (@options[:num_workers]     || server_ns::DEFAULT_NUM_WORKERS).to_i
+      @logger           = @options[:logger]
+      @worker_params    = @options[:worker_params]
+
+      @ip                      = nil
+      @port                    = nil
+      @file_descriptor         = nil
       @client_file_descriptors = []
-      @logger = DatTCP::Logger::Null.new
-
-      @worker_start_procs    = []
-      @worker_shutdown_procs = []
-      @worker_sleep_procs    = []
-      @worker_wakeup_procs   = []
 
       @waiting_for_pause = nil
-      @waiting_for_stop = nil
-      @waiting_for_halt = nil
+      @waiting_for_stop  = nil
+      @waiting_for_halt  = nil
 
-      @listen_called = false
+      @listen_called      = false
       @stop_listen_called = false
-      @start_called = false
-      @pause_called = false
-      @stop_called = false
-      @halt_called = false
-
-      @serve_proc = proc{ }
+      @start_called       = false
+      @pause_called       = false
+      @stop_called        = false
+      @halt_called        = false
     end
 
     def listening?
@@ -64,8 +68,8 @@ module DatTCP
       @stop_listen_called = true
     end
 
-    def start(client_file_descriptors = nil)
-      @client_file_descriptors = client_file_descriptors || []
+    def start(passed_client_fds = nil)
+      @client_file_descriptors = passed_client_fds || []
       @start_called = true
     end
 
@@ -84,11 +88,6 @@ module DatTCP
       @halt_called = true
     end
 
-    def on_worker_start(&block);    @worker_start_procs << block;    end
-    def on_worker_shutdown(&block); @worker_shutdown_procs << block; end
-    def on_worker_sleep(&block);    @worker_sleep_procs << block;    end
-    def on_worker_wakeup(&block);   @worker_wakeup_procs << block;   end
-
   end
 
 end

data/lib/dat-tcp/version.rb

@@ -1,3 +1,3 @@
 module DatTCP
-  VERSION = "0.7.0"
+  VERSION = "0.8.0"
 end

data/lib/dat-tcp/worker.rb

@@ -0,0 +1,26 @@
+require 'dat-worker-pool/worker'
+
+module DatTCP
+
+  module Worker
+
+    def self.included(klass)
+      klass.class_eval do
+        include DatWorkerPool::Worker
+
+      end
+    end
+
+    module TestHelpers
+
+      def self.included(klass)
+        klass.class_eval do
+          include DatWorkerPool::Worker::TestHelpers
+        end
+      end
+
+    end
+
+  end
+
+end

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: dat-tcp
 version: !ruby/object:Gem::Version 
-  hash: 3
+  hash: 63
   prerelease: 
   segments: 
   - 0
-  - 7
+  - 8
   - 0
-  version: 0.7.0
+  version: 0.8.0
 platform: ruby
 authors: 
 - Collin Redding
@@ -16,7 +16,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2015-09-08 00:00:00 Z
+date: 2015-11-30 00:00:00 Z
 dependencies: 
 - !ruby/object:Gem::Dependency 
   requirement: &id001 !ruby/object:Gem::Requirement 
@@ -24,11 +24,11 @@ dependencies:
     requirements: 
     - - ~>
       - !ruby/object:Gem::Version 
-        hash: 1
+        hash: 7
         segments: 
         - 0
-        - 5
-        version: "0.5"
+        - 6
+        version: "0.6"
   type: :runtime
   name: dat-worker-pool
   version_requirements: *id001
@@ -48,6 +48,21 @@ dependencies:
   name: assert
   version_requirements: *id002
   prerelease: false
+- !ruby/object:Gem::Dependency 
+  requirement: &id003 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        hash: 7
+        segments: 
+        - 3
+        - 0
+        version: "3.0"
+  type: :development
+  name: scmd
+  version_requirements: *id003
+  prerelease: false
 description: A generic threaded TCP server API.  It is designed for use as a base for application servers.
 email: 
 - collin.redding@me.com
@@ -63,9 +78,9 @@ files:
 - Rakefile
 - dat-tcp.gemspec
 - lib/dat-tcp.rb
-- lib/dat-tcp/logger.rb
 - lib/dat-tcp/server_spy.rb
 - lib/dat-tcp/version.rb
+- lib/dat-tcp/worker.rb
 homepage: https://github.com/redding/dat-tcp
 licenses: 
 - MIT

data/lib/dat-tcp/logger.rb

@@ -1,36 +0,0 @@
-# DatTCP's logger module acts as a generator for either a debug or null logger.
-# This allows the server and workers to always assume they have some logger
-# object and not have to worry about conditionally checking if a logger is
-# present. The null logger takes all messages and does nothing with them. When
-# debug mode is turned off, this logger is used, which keeps the server from
-# logging. The debug logger uses an instance of ruby's standard logger and
-# writes to STDOUT.
-#
-require 'logger'
-
-module DatTCP::Logger
-
-  def self.new(debug)
-     !!debug ? DatTCP::Logger::Debug.new : DatTCP::Logger::Null.new
-  end
-
-  module Debug
-
-    def self.new
-      ::Logger.new(STDOUT).tap do |logger|
-        logger.progname = "[#{self.name}]"
-        logger.datetime_format = "%m/%d/%Y %H:%M:%S%p "
-      end
-    end
-
-  end
-
-  class Null
-
-    Logger::Severity.constants.each do |name|
-      define_method(name.downcase){|*args| } # no-op
-    end
-
-  end
-
-end