dat-tcp 0.1.0

data/Gemfile

@@ -0,0 +1,6 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in tcp_server.gemspec
+gemspec
+
+gem 'rake'

data/Rakefile

@@ -0,0 +1,6 @@
+require "bundler/gem_tasks"
+
+require 'bench/tasks'
+
+require "assert/rake_tasks"
+Assert::RakeTasks.install

data/dat-tcp.gemspec

@@ -0,0 +1,25 @@
+# -*- encoding: utf-8 -*-
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'dat-tcp/version'
+
+Gem::Specification.new do |gem|
+  gem.name          = "dat-tcp"
+  gem.version       = DatTCP::VERSION
+  gem.authors       = ["Collin Redding"]
+  gem.email         = ["collin.redding@me.com"]
+  gem.description   = "DatTCP is a generic threaded TCP server implementation. It provides a " \
+                      "simple to use interface for defining a TCP server. It is intended to be " \
+                      "used as a base for application-level servers."
+  gem.summary       = "DatTCP is a generic threaded TCP server for defining application-level " \
+                      "servers."
+  gem.homepage      = ""
+
+  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_development_dependency('assert',        ['~>0.8'])
+  gem.add_development_dependency('assert-mocha',  ['~>0.1'])
+end

data/lib/dat-tcp.rb

@@ -0,0 +1,158 @@
+# DatTCP Server module is the main interface for defining a new server. It
+# should be mixed in and provides methods for starting and stopping the main
+# server loop. The `serve` method is intended to be overwritten so users can
+# define handling connections. It's primary loop is:
+#
+# 1. Wait for worker
+# 1. Accept connection
+# 2. Process connection by handing off to worker
+#
+# This is repeated until the server is stopped.
+#
+# Options:
+#   `max_workers`   - (integer) The maximum number of workers for processing
+#                     connections. More threads causes more concurrency but also
+#                     more overhead. This defaults to 4 workers.
+#   `debug`         - (boolean) Whether or not to have the server log debug
+#                     messages for when the server starts and stops and when a
+#                     client connects and disconnects.
+#   `ready_timeout` - (float) The timeout used with `IO.select` waiting for a
+#                     connection to occur. This can be set to 0 to not wait at
+#                     all. Defaults to 1 (second).
+#
+require 'logger'
+require 'socket'
+require 'thread'
+
+require 'dat-tcp/logger'
+require 'dat-tcp/workers'
+require 'dat-tcp/version'
+
+module DatTCP
+
+  module Server
+    attr_reader :host, :port, :workers, :debug, :logger, :ready_timeout
+    attr_reader :tcp_server, :thread
+
+    def initialize(host, port, options = nil)
+      options ||= {}
+      options[:max_workers] ||= 4
+
+      @host, @port = [ host, port ]
+      @logger = DatTCP::Logger.new(options[:debug])
+      @workers = DatTCP::Workers.new(options[:max_workers], self.logger)
+      @ready_timeout = options[:ready_timeout] || 1
+
+      @mutex = Mutex.new
+      @condition_variable = ConditionVariable.new
+    end
+
+    def start
+      if !self.running?
+        @shutdown = false
+        !!self.start_server_thread
+      else
+        false
+      end
+    end
+
+    def stop
+      if self.running?
+        @shutdown = true
+        @mutex.synchronize do
+          while self.thread
+            @condition_variable.wait(@mutex)
+          end
+        end
+      else
+        false
+      end
+    end
+
+    def join_thread(limit = nil)
+      @thread.join(limit) if self.running?
+    end
+
+    def running?
+      !!@thread
+    end
+
+    # This method should be overwritten to handle new connections
+    def serve(socket)
+    end
+
+    def name
+      "#{self.class}|#{self.host}:#{self.port}"
+    end
+
+    def inspect
+      reference = '0x0%x' % (self.object_id << 1)
+      "#<#{self.class}:#{reference} @host=#{self.host.inspect} @port=#{self.port.inspect}>"
+    end
+
+    protected
+
+    def start_server_thread
+      @tcp_server = TCPServer.new(self.host, self.port)
+      @mutex.synchronize do
+        @thread = Thread.new{ self.work_loop }
+      end
+    end
+
+    # Notes:
+    # * If the server has been shutdown, then `accept_connection` will return
+    #   `nil` always. This will exit the loop and begin shutting down the server.
+    def work_loop
+      self.logger.info("Starting...")
+      while !@shutdown
+        connection = self.accept_connection
+        self.workers.process(connection){|client| self.serve(client) } if connection
+      end
+    rescue Exception => exception
+      self.logger.info("Exception occurred, stopping server!")
+    ensure
+      self.shutdown_server_thread(exception)
+    end
+
+    # This method is a accept-loop waiting for a new connection. It uses
+    # `IO.select` with a timeout to wait for a socket to be ready. Once the
+    # socket is ready, it calls `accept` and returns the connection. If the
+    # server socket doesn't have a new connection waiting, the loop starts over.
+    # In the case the server has been shutdown, it will also break out of the
+    # loop.
+    #
+    # Notes:
+    # * If the server has been shutdown this will return `nil`.
+    def accept_connection
+      loop do
+        if IO.select([ @tcp_server ], nil, nil, self.ready_timeout)
+          return @tcp_server.accept
+        elsif @shutdown
+          return
+        end
+      end
+    end
+
+    # Notes:
+    # * Stopping the workers is a graceful shutdown. It will let them each finish
+    #   processing by joining their threads.
+    def shutdown_server_thread(exception = nil)
+      self.logger.info("Stopping...")
+      @tcp_server.close rescue false
+      self.logger.info("  letting any running workers finish...")
+      self.workers.finish
+      self.logger.info("Stopped")
+      if exception
+        self.logger.error("#{exception.class}: #{exception.message}")
+        self.logger.error(exception.backtrace.join("\n"))
+      end
+      @mutex.synchronize do
+        @thread = nil
+        @condition_variable.signal
+      end
+      true
+    end
+
+  end
+
+end

data/lib/dat-tcp/logger.rb

@@ -0,0 +1,36 @@
+# 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

data/lib/dat-tcp/version.rb

@@ -0,0 +1,3 @@
+module DatTCP
+  VERSION = "0.1.0"
+end

data/lib/dat-tcp/workers.rb

@@ -0,0 +1,99 @@
+# DatTCP's workers is a class for managing the worker threads that are
+# spun up to handle clients. It manages a list of working threads and provides
+# external methods for working with them. Working threads are managed by
+# creating a new one when `process` is called. A client connection and a block
+# are passed to the worker thread for it to handle the connection. Once it's
+# done handling the thread, the connection is closed and the thread is removed
+# from the list. This iignals some of the other methods that the workers class
+# provides that wait on threads to finish.
+#
+require 'thread'
+
+require 'dat-tcp/logger'
+
+module DatTCP
+
+  class Workers
+    attr_reader :max, :list, :logger
+
+    def initialize(max = 1, logger = nil)
+      @max = max
+      @logger = logger || DatTCP::Logger::Null.new
+      @list = []
+
+      @mutex = Mutex.new
+      @condition_variable = ConditionVariable.new
+    end
+
+    # This uses the mutex and condition variable to sleep the current thread
+    # until signaled. When a thread closes down, it signals, causing this thread
+    # to wakeup. This will run the loop again, and as long as a worker is
+    # available, the method will return. Otherwise it will sleep again waiting
+    # to be signaled.
+    def wait_for_available
+      @mutex.synchronize do
+        while self.list.size >= self.max
+          @condition_variable.wait(@mutex)
+        end
+      end
+    end
+
+    def process(connecting_socket, &block)
+      self.wait_for_available
+      worker_id = self.list.size + 1
+      @list << Thread.new{ self.serve_client(worker_id, connecting_socket, &block) }
+    end
+
+    # Finish simply sleeps the current thread until signaled. Again, when a
+    # worker thread closes down, it signals. This will cause this to wake up and
+    # continue running the loop. Once the list is empty, the method will return.
+    # Otherwise this will sleep until signaled again. This is a graceful
+    # shutdown, letting the threads finish their processing.
+    def finish
+      @mutex.synchronize do
+        @list.reject!{|thread| !thread.alive? }
+        while !self.list.empty?
+          @condition_variable.wait(@mutex)
+        end
+      end
+    end
+
+    protected
+
+    def log(message, worker_id)
+      self.logger.info("[Worker##{worker_id}] #{message}") if self.logger
+    end
+
+    def serve_client(worker_id, connecting_socket, &block)
+      begin
+        Thread.current["client_address"] = connecting_socket.peeraddr[1, 2].reverse.join(':')
+        self.log("Connecting #{Thread.current["client_address"]}", worker_id)
+        block.call(connecting_socket)
+      rescue Exception => exception
+        self.log("Exception occurred, stopping worker", worker_id)
+      ensure
+        self.disconnect_client(worker_id, connecting_socket, exception)
+      end
+    end
+
+    # Closes the client connection and also shuts the thread down. This is done
+    # by removing the thread from the list. This is wrapped in a mutex
+    # synchronize, to ensure only one thread interacts with list at a time. Also
+    # the condition variable is signaled to trigger the `finish` or
+    # `wait_for_available` methods.
+    def disconnect_client(worker_id, connecting_socket, exception)
+      connecting_socket.close rescue false
+      @mutex.synchronize do
+        @list.delete(Thread.current)
+        @condition_variable.signal
+      end
+      if exception
+        self.log("#{exception.class}: #{exception.message}", worker_id)
+        self.log(exception.backtrace.join("\n"), worker_id)
+      end
+      self.log("Disconnecting #{Thread.current["client_address"]}", worker_id)
+    end
+
+  end
+
+end

metadata

@@ -0,0 +1,101 @@
+--- !ruby/object:Gem::Specification 
+name: dat-tcp
+version: !ruby/object:Gem::Version 
+  hash: 27
+  prerelease: 
+  segments: 
+  - 0
+  - 1
+  - 0
+  version: 0.1.0
+platform: ruby
+authors: 
+- Collin Redding
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2012-11-14 00:00:00 Z
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  prerelease: false
+  version_requirements: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        hash: 27
+        segments: 
+        - 0
+        - 8
+        version: "0.8"
+  requirement: *id001
+  name: assert
+  type: :development
+- !ruby/object:Gem::Dependency 
+  prerelease: false
+  version_requirements: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        hash: 9
+        segments: 
+        - 0
+        - 1
+        version: "0.1"
+  requirement: *id002
+  name: assert-mocha
+  type: :development
+description: DatTCP is a generic threaded TCP server implementation. It provides a simple to use interface for defining a TCP server. It is intended to be used as a base for application-level servers.
+email: 
+- collin.redding@me.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- Gemfile
+- Rakefile
+- dat-tcp.gemspec
+- lib/dat-tcp.rb
+- lib/dat-tcp/logger.rb
+- lib/dat-tcp/version.rb
+- lib/dat-tcp/workers.rb
+homepage: ""
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.8.15
+signing_key: 
+specification_version: 3
+summary: DatTCP is a generic threaded TCP server for defining application-level servers.
+test_files: []
+