zerg_support 0.0.9 → 0.1

data/CHANGELOG

@@ -1,3 +1,5 @@
+v0.1. Socket primitives.
+
 v0.0.9. Changed ProcTable wrapper to deal with API change in 0.8.0.
 
 v0.0.8. Extension emulation works in Windows without a build environment.

data/Manifest

@@ -1,10 +1,14 @@
 CHANGELOG
 lib/zerg_support/event_machine/connection_mocks.rb
-lib/zerg_support/event_machine/frame_protocol.rb
-lib/zerg_support/event_machine/object_protocol.rb
+lib/zerg_support/event_machine/protocol_adapter.rb
 lib/zerg_support/gems.rb
 lib/zerg_support/open_ssh.rb
 lib/zerg_support/process.rb
+lib/zerg_support/protocols/frame_protocol.rb
+lib/zerg_support/protocols/object_protocol.rb
+lib/zerg_support/socket_factory.rb
+lib/zerg_support/sockets/protocol_adapter.rb
+lib/zerg_support/sockets/socket_mocks.rb
 lib/zerg_support/spawn.rb
 lib/zerg_support.rb
 LICENSE
@@ -19,4 +23,5 @@ test/test_gems.rb
 test/test_object_protocol.rb
 test/test_open_ssh.rb
 test/test_process.rb
+test/test_socket_factory.rb
 test/test_spawn.rb

data/lib/zerg_support/event_machine/connection_mocks.rb

@@ -1,6 +1,9 @@
+# :nodoc: namespace
+module Zerg::Support::EventMachine
+
 # Mocks the sending end of an EventMachine connection.
 # The sent data is concatenated in a string available by calling #string.
-class Zerg::Support::EventMachine::SendMock  
+class SendMock  
   attr_reader :string
   
   def initialize
@@ -10,17 +13,17 @@ class Zerg::Support::EventMachine::SendMock
   def send_data(data)
     @string << data
   end
-end
+end  # class SendMock
 
 # Mocks the receiving end of an EventMachine connection.
 # The data to be received is passed as an array of strings to the constructor.
 # Calling #replay mocks receiving the data.
-class Zerg::Support::EventMachine::ReceiveMock
+class ReceiveMock
   attr_accessor :strings
   attr_accessor :objects
   
   def initialize(strings = [''])
-    @strings = strings
+    @strings = strings.kind_of?(String) ? [strings] : strings
     @objects = []
   end
   
@@ -30,17 +33,14 @@ class Zerg::Support::EventMachine::ReceiveMock
     self
   end
 
-  #:nodoc:
-  def receive__object(object)
-    @objects << object
-  end
-  
   # Declares the name of the object to be received. For instance, a frame
   # protocol would use :frame for name. This generates a receive_frame method,
   # and a frames accessor.
   def self.object_name(name)
-    alias_method "receive_#{name}".to_sym, :receive__object
+    define_method(:"receive_#{name}") { |object| @objects << object }
     return if name == :object
-    alias_method "#{name}s".to_sym, :objects
+    alias_method :"#{name}s", :objects
   end
-end
+end  # class ReceiveMock
+
+end  # namespace Zerg::Support::EventMachine

data/lib/zerg_support/event_machine/protocol_adapter.rb

@@ -0,0 +1,53 @@
+# :nodoc: namespace
+module Zerg::Support::EventMachine
+
+# Adapts generic Protocol modules for easy inclusion in EventMachine connection
+# classes / modules.
+module ProtocolAdapter
+  def self.adapter_module(protocol_module, object_name = nil)    
+    unless object_name
+      object_name = /(^|:)([^:]*)Protocol$/.
+          match(protocol_module.name)[2].split(/(?=[A-Z])/).join('_').downcase
+    end
+    
+    state_class = Class.new StateBase
+    state_class.send :include, protocol_module
+    state_class.class_eval do
+      # Called by the protocol when an entire object is available.
+      define_method :"received_#{object_name}" do |object|
+        @target.send :"receive_#{object_name}", object
+      end
+    end
+    
+    adapter = Module.new
+    adapter.module_eval do
+      # Called by Event Machine when TCP stream data is available.
+      define_method :receive_data do |data|
+        @zerg_protocol_adapter_state ||= state_class.new self
+        @zerg_protocol_adapter_state.received_bytes data
+      end
+
+      # Called by the Event Machine user to send data.
+      define_method :"send_#{object_name}" do |object|
+        @zerg_protocol_adapter_state ||= state_class.new self
+        @zerg_protocol_adapter_state.send :"send_#{object_name}", object
+      end
+    end
+    
+    adapter
+  end
+  
+  # Base class for the adapter state.
+  class StateBase
+    def initialize(target)
+      @target = target
+    end
+
+    # Called by the protocol when an entire object is available.
+    def send_bytes(data)
+      @target.send_data data
+    end
+  end
+end
+
+end  # namespace Zerg::Support::EventMachine

data/lib/zerg_support/process.rb

@@ -127,11 +127,10 @@ module Zerg::Support::Process
       self.kill_primitive pid, false
       Thread.new(pid) do |victim_pid|
         Kernel.sleep 0.2
-        self.kill_primitive pid, true
+        self.kill_primitive(pid, true) rescue nil
       end
     rescue
       # we probably don't have the right to kill the process
-      print "#{$!.class.name}: #{$!}\n"
     end    
   end
   

data/lib/zerg_support/{event_machine → protocols}/frame_protocol.rb

@@ -1,10 +1,10 @@
 #:nodoc: namespace
-module Zerg::Support::EventMachine
+module Zerg::Support::Protocols
   
-# Event Machine protocol for sending and receiving discrete-sized frames
-module FrameProtocol  
-  #:nodoc: This is called by Event Machine when TCP stream data is available.
-  def receive_data(data)
+# Protocol for sending and receiving discrete-sized frames over TCP streams.
+module FrameProtocol
+  # Called when data is available from the TCP stream.
+  def received_bytes(data)
     @frame_protocol_varsize ||= ''
 
     i = 0
@@ -22,7 +22,7 @@ module FrameProtocol
       return if @frame_protocol_buffer.nil?
       break if @frame_protocol_bytes_left > data.size - i
 
-      receive_frame @frame_protocol_buffer + data[i, @frame_protocol_bytes_left]
+      received_frame @frame_protocol_buffer + data[i, @frame_protocol_bytes_left]
       @frame_protocol_varsize, @frame_protocol_buffer = '', nil
       i += @frame_protocol_bytes_left
     end
@@ -32,14 +32,19 @@ module FrameProtocol
   end
   
   # Override to process incoming frames.
-  def receive_frame(frame_data); end
+  def received_frame(frame_data); end
 
-  # Sends a frame via the underlying Event Machine TCP stream.
+  # Sends a frame via the underlying TCP stream.
   def send_frame(frame_data)
-    encoded_length = FrameProtocol.encode_natural(frame_data.length)
-    send_data encoded_length + frame_data
+    send_bytes FrameProtocol.encode_frame(frame_data)
   end
   
+  # :nodoc: Encodes frame data into data to be sent across a TCP wire.
+  def self.encode_frame(frame_data)
+    encoded_length = FrameProtocol.encode_natural(frame_data.length)
+    encoded_length + frame_data
+  end
+
   #:nodoc: Encodes a natural (non-negative) integer into a string.
   def self.encode_natural(number)
     string = ''
@@ -65,4 +70,4 @@ module FrameProtocol
   end  
 end
 
-end # namespace Zerg::Support::EventMachine
+end  # namespace Zerg::Support::Protocols

data/lib/zerg_support/{event_machine → protocols}/object_protocol.rb

@@ -1,7 +1,7 @@
 require 'yaml'
 
 #:nodoc: namespace
-module Zerg::Support::EventMachine
+module Zerg::Support::Protocols
 
 # Event Machine protocol for sending serializable objects.
 module ObjectProtocol
@@ -13,12 +13,12 @@ module ObjectProtocol
   end
   
   #:nodoc: Processes an incoming frame and de-serializes the object in it.
-  def receive_frame(frame_data)
-    receive_object YAML.load(frame_data)
+  def received_frame(frame_data)
+    received_object YAML.load(frame_data)
   end
   
   # Override to process incoming objects.
-  def receive_object(object); end
+  def received_object(object); end
 end
 
-end # namespace Zerg::Support::EventMachine
+end  # namespace Zerg::Support::Protocols

data/lib/zerg_support/socket_factory.rb

@@ -0,0 +1,198 @@
+require 'socket'
+
+# :nodoc: namespace
+module Zerg::Support
+
+module SocketFactory
+  # Splits a host:port IP address into its components. IPv6 addresses welcome.
+  #
+  # The port will be nil if the IP address doesn't contain it.
+  def self.split_address(address)
+    port_match = /(^|[^:])\:([^:].*)$/.match(address)
+    if port_match
+      port = port_match[2]
+      host = address[0, address.length - port.length - 1]
+      [(host.empty? ? nil : host), port]
+    else
+      [address, nil]
+    end
+  end  
+  
+  # The host from a host:port IP address.
+  #
+  # Empty string if the IP address does not contain a host (e.g. :3000)
+  def self.host_from_address(address)
+    address and split_address(address)[0]
+  end
+  
+  # The port from a host:port IP address.
+  #
+  # nil if the IP address does not contain a port (e.g. localhost)
+  def self.port_from_address(address)
+    address and (port_string = split_address(address)[1]) and port_string.to_i
+  end
+
+  # True for options requesting a connecting (as opposed to listening) socket.
+  def self.outbound?(options)
+    [:out_port, :out_host, :out_addr].any? { |k| options[k] }
+  end
+  
+  # The host from a host:port IP address, in a form suitable for bind().
+  def self.bind_host(options)
+    host_from_address(options[:in_addr]) or options[:in_host] or '0.0.0.0'
+  end
+  
+  # The port from a host:port IP address, in a form suitable for bind().
+  def self.bind_port(options)
+    port_from_address(options[:in_addr]) or options[:in_port] or 0
+  end
+
+  # An address suitable for bind() based on the options.
+  def self.bind_socket_address(options)
+    Socket::pack_sockaddr_in bind_port(options), bind_host(options)
+  end
+
+  # The host from a host:port IP address, in a form suitable for connect().
+  def self.connect_host(options)
+    options[:out_host] or host_from_address(options[:out_addr]) or 'localhost'
+  end
+
+  # The port from a host:port IP address, in a form suitable for connect().  
+  def self.connect_port(options)
+    port_from_address(options[:out_addr]) or options[:out_port]
+  end
+  
+  # True if the options indicate TCP should be used, false for UDP.  
+  def self.tcp?(options)
+    options[:tcp] or !options[:udp]
+  end
+
+  # The socket() type based on the options.  
+  def self.socket_type(options)
+    tcp?(options) ? Socket::SOCK_STREAM : Socket::SOCK_DGRAM
+  end
+  
+  # Sets socket flags (via setsockopt) based on the options.
+  def self.set_options(socket, options)
+    if options[:no_delay]
+      if tcp?(options)
+        socket.setsockopt Socket::IPPROTO_TCP, Socket::TCP_NODELAY, true
+      end
+      socket.sync = true
+    end
+    
+    if options[:reuse_addr]
+      socket.setsockopt Socket::SOL_SOCKET, Socket::SO_REUSEADDR, true
+    end
+    
+    unless options[:reverse_lookup]
+      if socket.respond_to? :do_not_reverse_lookup
+        socket.do_not_reverse_lookup = true
+      else
+        # work around until the patch below actually gets committed:
+        # http://blade.nagaokaut.ac.jp/cgi-bin/scat.rb/ruby/ruby-core/2346
+        BasicSocket.do_not_reverse_lookup = true
+      end
+    end
+  end
+
+  # Hacks a socket's accept method so that new sockets have the given flags set.
+  #
+  # The flags are set in a similar manner to set_options.
+  def self.set_options_on_accept_sockets(socket, options)
+    socket.instance_variable_set :@zerg_support_factory_options, options
+    def socket.accept(*args)
+      sock, addr = super
+      Zerg::Support::SocketFactory.set_options sock,
+                                               @zerg_support_factory_options
+      return sock, addr
+    end
+  end
+  
+  # Sugar-coat the socket's listen() call with a default value for its argument.
+  def self.sugar_socket_listen(socket)
+    def socket.listen(*args)
+      args = [1000] if args.empty?
+      super(*args)
+    end
+  end
+  
+  # Binds a socket to an address based on the options.
+  def self.bind(socket, options)
+    socket.bind bind_socket_address(options)    
+    socket
+  end
+  
+  # New inbound socket based on the options.
+  def self.new_inbound_socket(options)
+    socket = Socket.new Socket::AF_INET, socket_type(options), Socket::PF_UNSPEC
+    set_options socket, options
+    set_options_on_accept_sockets socket, options
+    sugar_socket_listen socket
+    bind socket, options    
+  end
+  
+  # Retrieves possible IP addresses to connect to based on the given options.
+  #
+  # The retrieval is done via setsockopt.
+  def self.addr_infos(options)
+    Socket.getaddrinfo connect_host(options), connect_port(options),
+                       Socket::AF_INET, socket_type(options)
+  end  
+  
+  # New outbound socket based on an address obtained from getaddrinfo().
+  def self.new_outbound_socket_with_addr_info(addr_info)
+    Socket.new addr_info[4], addr_info[5], addr_info[6]
+  end
+  
+  # Connects a socket to an address obtained from getaddrinfo().
+  #
+  # Returns the socket for success, or nil if the connection failed.
+  def self.connect_with_addr_info(socket, addr_info)
+    begin      
+      socket.connect Socket.pack_sockaddr_in(addr_info[1], addr_info[3])
+      socket
+    rescue
+      nil
+    end    
+  end
+
+  # New outbound socket based on the options.
+  def self.new_outbound_socket(options)
+    addr_infos = self.addr_infos options
+    addr_infos.each do |addr_info|
+      socket = new_outbound_socket_with_addr_info addr_info
+      set_options socket, options      
+      return socket if connect_with_addr_info socket, addr_info
+      socket.close rescue nil
+    end
+    nil
+  end
+  
+  # Kitchen-sink socket creation method. The following options are supported:
+  #   tcp:: forces the use of TCP (overrides the udp option)
+  #   udp:: selects UDP (the default is TCP)
+  #   out_port:: the port to connect an outgoing socket to
+  #   out_host:: the host to connect an outgoing socket to
+  #   out_addr:: the host:port address to connect an outgoing socket to; the
+  #              host and port override out_port and out_host, which can be used
+  #              in conjunction with out_addr to provide default values
+  #   in_port:: the port to bind a listening socket to
+  #   in_host:: the host to bind a listening socket to
+  #   in_addr:: the host:port address to bind a listening socket to; the host
+  #              and port override in_port and in_host, which can be used in
+  #              conjunction with in_addr to provide default values
+  #   no_delay:: disables Nagles' algorithm
+  #   reuse_addr:: allows binding other sockets to this socket's address
+  #   reverse_lookup:: enables reverse lookups on connections; this is the Ruby
+  #                    default, but ZergSupport changes it for performance
+  def self.socket(options)
+    if outbound? options
+      new_outbound_socket options
+    else      
+      new_inbound_socket options
+    end
+  end
+end  # class SocketFactory
+
+end  # namespace Zerg::Support

data/lib/zerg_support/sockets/protocol_adapter.rb

@@ -0,0 +1,59 @@
+# :nodoc: namespace
+module Zerg::Support::Sockets
+
+# Adapts generic Protocol modules to modules that can extend sockets.
+module ProtocolAdapter
+  def self.adapter_module(protocol_module, object_name = nil)    
+    unless object_name
+      object_name = /(^|:)([^:]*)Protocol$/.
+          match(protocol_module.name)[2].split(/(?=[A-Z])/).join('_').downcase
+    end
+    
+    state_class = Class.new StateBase
+    state_class.send :include, protocol_module
+    state_class.class_eval do
+      # Called by the protocol when an entire object is available.
+      define_method :"received_#{object_name}" do |object|
+        @recv_object_buffer << object
+      end
+    end
+    
+    adapter = Module.new
+    adapter.module_eval do
+      # Receives an object from a socket.
+      define_method :"recv_#{object_name}" do
+        @zerg_protocol_adapter_state ||= state_class.new self
+        while @zerg_protocol_adapter_state.recv_object_buffer.length == 0
+          data = recv 65536
+          return nil if data.length == 0  # Other side closed socket.
+          @zerg_protocol_adapter_state.received_bytes data
+        end
+        @zerg_protocol_adapter_state.recv_object_buffer.shift
+      end
+
+      # Sends an object across a socket.
+      define_method :"send_#{object_name}" do |object|
+        @zerg_protocol_adapter_state ||= state_class.new self
+        @zerg_protocol_adapter_state.send :"send_#{object_name}", object
+      end
+    end
+    
+    adapter
+  end
+  
+  # Base class for the adapter state.
+  class StateBase
+    attr_reader :recv_object_buffer
+    def initialize(target)
+      @recv_object_buffer = []
+      @target = target
+    end
+
+    # Called by the protocol when an entire object is available.
+    def send_bytes(data)
+      @target.send data, 0
+    end
+  end
+end
+
+end  # namespace Zerg::Support::Sockets

data/lib/zerg_support/sockets/socket_mocks.rb

@@ -0,0 +1,60 @@
+# :nodoc: namespace
+module Zerg::Support::Sockets
+
+# Mocks the sending end of a Socket connection.
+# The sent data is concatenated in a string available by calling #string.
+class SendMock  
+  attr_reader :string
+  
+  def initialize
+    @string = ''
+  end
+  
+  def send(data, flags)
+    @string << data
+  end
+end  # class SendMock
+
+# Mocks the receiving end of a Socket connection.
+# The data to be received is passed as an array of strings to the constructor.
+class ReceiveMock
+  attr_accessor :strings
+  attr_accessor :objects
+  
+  def initialize(strings = [''])
+    @strings = strings.kind_of?(String) ? [strings] : strings
+    @objects = []
+  end
+  
+  def recv(byte_limit)
+    bytes = @strings.shift
+    return '' unless bytes
+    if bytes.length > byte_limit
+      @strings.unshift bytes[byte_limit, bytes.length]
+      bytes = bytes[0, byte_limit]
+    end
+    bytes
+  end
+  
+  # Declares the name of the object to be received. For instance, a frame
+  # protocol would use :frame for name. This generates a receive_frame method,
+  # and a frames accessor.
+  def self.object_name(name)
+    # Calls recv_object until the bytes buffer is drained.
+    define_method :replay do
+      while @strings.length > 0
+        @objects << self.send(:"recv_#{name}")
+      end
+      loop do
+        object = self.send(:"recv_#{name}")
+        break unless object
+        @objects << object
+      end
+      self
+    end
+    return if name == :object
+    alias_method :"#{name}s", :objects
+  end  
+end  # class ReceiveMock
+
+end  # namespace Zerg::Support::Sockets

data/lib/zerg_support.rb

@@ -1,4 +1,4 @@
-# :nodoc
+# :nodoc: namespace
 module Zerg
 end
 
@@ -10,12 +10,11 @@ require 'rubygems'
 require 'zerg_support/gems.rb'
 require 'zerg_support/process.rb'
 require 'zerg_support/open_ssh.rb'
+require 'zerg_support/socket_factory.rb'
 require 'zerg_support/spawn.rb'
-
-# TODO(victor): document this
-module Zerg::Support::EventMachine  
-end
-
 require 'zerg_support/event_machine/connection_mocks.rb'
-require 'zerg_support/event_machine/frame_protocol.rb'
-require 'zerg_support/event_machine/object_protocol.rb'
+require 'zerg_support/event_machine/protocol_adapter.rb'
+require 'zerg_support/protocols/frame_protocol.rb'
+require 'zerg_support/protocols/object_protocol.rb'
+require 'zerg_support/sockets/protocol_adapter.rb'
+require 'zerg_support/sockets/socket_mocks.rb'

data/test/test_frame_protocol.rb

@@ -2,23 +2,12 @@ require 'zerg_support'
 
 require 'test/unit'
 
-class TestFrameProtocol < Test::Unit::TestCase
-  FP = Zerg::Support::EventMachine::FrameProtocol
-
-  # Send mock for frames.
-  class SendFramesMock < Zerg::Support::EventMachine::SendMock
-    include FP
-  end
-
-  # Receive mock for frames.
-  class ReceiveFramesMock < Zerg::Support::EventMachine::ReceiveMock
-    include FP
-    object_name :frame
-  end
+module FrameProtocolTestMethods
+  FP = Zerg::Support::Protocols::FrameProtocol
 
   def setup
     super
-    @send_mock = SendFramesMock.new
+    @send_mock = self.class::SendFramesMock.new    
   end
   
   def teardown
@@ -38,12 +27,13 @@ class TestFrameProtocol < Test::Unit::TestCase
       i += sublen
     end
     in_strings << in_string[i..-1] if i < in_string.length
-    out_frames = ReceiveFramesMock.new(@send_mock.string).replay.frames
+    out_frames =
+        self.class::ReceiveFramesMock.new(@send_mock.string).replay.frames
     assert_equal frames, out_frames
   end
 
   def test_empty_frame
-    continuous_data_test ['']    
+    continuous_data_test ['']
   end
   
   def test_byte_frame
@@ -88,7 +78,7 @@ class TestFrameProtocol < Test::Unit::TestCase
     ex_frames = [s2_frame] * s2_count
     
     # build cut points in a string
-    s2_points = [0, 1, 2, 3, 4, 5, 127, 128, 8190, 16381, 16382, 16383]
+    s2_points = [1, 2, 3, 4, 5, 127, 128, 8190, 16381, 16382, 16383]
     cut_points = []
     0.upto(s2_count - 1) do |i|
       cut_points += s2_points.map { |p| p + i * s2_string.length }
@@ -101,7 +91,8 @@ class TestFrameProtocol < Test::Unit::TestCase
           packets = [0...cut_points[i], cut_points[i]...cut_points[j],
                      cut_points[j]...cut_points[k], cut_points[k]..-1].
                     map { |r| send_string[r] }
-          assert_equal ex_frames, ReceiveFramesMock.new(packets).replay.frames
+          assert_equal ex_frames,
+              self.class::ReceiveFramesMock.new(packets).replay.frames
         end
       end
     end
@@ -115,5 +106,43 @@ class TestFrameProtocol < Test::Unit::TestCase
       assert_equal entry.last, FP.encode_natural(entry.first) 
       assert_equal entry.first, FP.decode_natural(entry.last) 
     end
+  end  
+end
+
+class FrameProtocolEventMachineTest < Test::Unit::TestCase
+  include FrameProtocolTestMethods
+  
+  ProtocolAdapter = Zerg::Support::EventMachine::ProtocolAdapter
+  FP = Zerg::Support::Protocols::FrameProtocol
+  FPAdapter = ProtocolAdapter.adapter_module FP
+  
+  # Send mock for frames.
+  class SendFramesMock < Zerg::Support::EventMachine::SendMock
+    include FPAdapter
+  end
+
+  # Receive mock for frames.
+  class ReceiveFramesMock < Zerg::Support::EventMachine::ReceiveMock
+    include FPAdapter
+    object_name :frame
+  end
+end
+
+class FrameProtocolSocketsTest < Test::Unit::TestCase
+  include FrameProtocolTestMethods
+  
+  ProtocolAdapter = Zerg::Support::Sockets::ProtocolAdapter
+  FP = Zerg::Support::Protocols::FrameProtocol
+  FPAdapter = ProtocolAdapter.adapter_module FP
+  
+  # Send mock for frames.
+  class SendFramesMock < Zerg::Support::Sockets::SendMock
+    include FPAdapter
+  end
+
+  # Receive mock for frames.
+  class ReceiveFramesMock < Zerg::Support::Sockets::ReceiveMock
+    include FPAdapter
+    object_name :frame
   end
-end
+end

data/test/test_object_protocol.rb

@@ -3,13 +3,15 @@ require 'test/unit'
 require 'zerg_support'
 
 class ObjectProtocolTest < Test::Unit::TestCase
-  OP = Zerg::Support::EventMachine::ObjectProtocol
+  ProtocolAdapter = Zerg::Support::EventMachine::ProtocolAdapter
+  OP = Zerg::Support::Protocols::ObjectProtocol
+  OPAdapter = ProtocolAdapter.adapter_module OP
   
   class SendObjectMock < Zerg::Support::EventMachine::SendMock
-    include OP
+    include OPAdapter
   end
   class ReceiveObjectMock < Zerg::Support::EventMachine::ReceiveMock
-    include OP
+    include OPAdapter
     object_name :object
   end
   
@@ -52,4 +54,4 @@ class ObjectProtocolTest < Test::Unit::TestCase
              "1234567890",
              {:command => 'run', :sequence => [1, nil, 2, true, "Q\n"]})
   end
-end
+end

data/test/test_process.rb

@@ -4,6 +4,11 @@ require 'test/unit'
 require 'zerg_support'
 
 class TestProcess < Test::Unit::TestCase
+  def setup
+    super
+    Thread.abort_on_exception = true
+  end
+  
   def teardown
     @pid_files.each { |f| File.delete f rescue nil } if @pid_files
     super

data/test/test_socket_factory.rb

@@ -0,0 +1,93 @@
+require 'test/unit'
+
+require 'zerg_support'
+
+
+class SocketFactoryTest < Test::Unit::TestCase
+  SF = Zerg::Support::SocketFactory
+  
+  OP = Zerg::Support::Protocols::ObjectProtocol
+  OPAdapter = Zerg::Support::Sockets::ProtocolAdapter.adapter_module OP
+  
+  def setup
+    Thread.abort_on_exception = true
+  end
+
+  def teardown
+    
+  end
+  
+  def test_host_from_address
+    assert_equal nil, SF.host_from_address(nil)
+    assert_equal nil, SF.host_from_address(':9000')
+    assert_equal '127.0.0.1', SF.host_from_address('127.0.0.1')
+    assert_equal '127.0.0.1', SF.host_from_address('127.0.0.1:1234')
+    assert_equal 'fe80::1%lo0', SF.host_from_address('fe80::1%lo0')
+    assert_equal 'fe80::1%lo0', SF.host_from_address('fe80::1%lo0:19020')
+  end
+  
+  def test_port_from_address
+    assert_equal nil, SF.port_from_address(nil)
+    assert_equal 9000, SF.port_from_address(':9000')
+    assert_equal nil, SF.port_from_address('127.0.0.1')
+    assert_equal 1234, SF.port_from_address('127.0.0.1:1234')
+    assert_equal nil, SF.port_from_address('fe80::1%lo0')
+    assert_equal 19020, SF.port_from_address('fe80::1%lo0:19020')
+  end
+  
+  def test_inbound
+    assert !SF.outbound?(:in_port => 1)
+    assert !SF.outbound?(:in_host => '1')
+    assert !SF.outbound?(:in_addr => '1')
+    assert SF.outbound?(:out_port => 1)
+    assert SF.outbound?(:out_host => '1')
+    assert SF.outbound?(:out_addr => '1')
+  end
+  
+  def test_tcp
+    assert SF.tcp?({})
+    assert SF.tcp?(:tcp => true)
+    assert !SF.tcp?(:udp => true)
+  end
+  
+  def _test_connection(server_options, client_options = nil)
+    client_options ||= server_options
+    test_port = 31996
+    
+    cli_gold = { :request_type => 1, :request_name => "moo" }
+    srv_gold = { :response_type => 2, :response_value => [true, 314] }
+    cli_hash = nil
+    
+    # Server thread.
+    Thread.new do
+      server = SF.socket({:in_addr => ":#{test_port}"}.merge server_options)
+      server.listen
+      serv_client, client_addrinfo = server.accept
+      serv_client.extend OPAdapter
+      cli_hash = serv_client.recv_object
+      serv_client.send_object srv_gold
+      serv_client.close
+      
+      server.close
+    end
+    
+    # Client.
+    client = SF.socket({:out_addr => "localhost:#{test_port}"}.
+                       merge(client_options))
+    client.extend OPAdapter
+    client.send_object cli_gold
+    srv_hash = client.recv_object
+    client.close
+    
+    # Checks
+    assert_equal cli_gold, cli_hash, "Client -> server failed"
+    assert_equal srv_gold, srv_hash, "Server -> client failed"
+  end
+  
+  def test_connection  
+    _test_connection({:no_delay => true})
+    _test_connection({:reuse_addr => true})
+    
+    # TODO(costan): fix UDP at some point
+  end
+end

data/test/test_spawn.rb

@@ -15,6 +15,7 @@ class TestSpawn < Test::Unit::TestCase
   
   def setup
     super
+    Thread.abort_on_exception = true
     @in_file = temp_file
     @out_file = temp_file
   end

data/zerg_support.gemspec

@@ -2,27 +2,26 @@
 
 Gem::Specification.new do |s|
   s.name = %q{zerg_support}
-  s.version = "0.0.9"
+  s.version = "0.1"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 1.2") if s.respond_to? :required_rubygems_version=
   s.authors = ["Victor Costan"]
-  s.date = %q{2009-03-28}
+  s.date = %q{2009-06-02}
   s.description = %q{Support libraries used by Zergling.Net deployment code.}
   s.email = %q{victor@zergling.net}
-  s.extra_rdoc_files = ["CHANGELOG", "lib/zerg_support/event_machine/connection_mocks.rb", "lib/zerg_support/event_machine/frame_protocol.rb", "lib/zerg_support/event_machine/object_protocol.rb", "lib/zerg_support/gems.rb", "lib/zerg_support/open_ssh.rb", "lib/zerg_support/process.rb", "lib/zerg_support/spawn.rb", "lib/zerg_support.rb", "LICENSE", "README"]
-  s.files = ["CHANGELOG", "lib/zerg_support/event_machine/connection_mocks.rb", "lib/zerg_support/event_machine/frame_protocol.rb", "lib/zerg_support/event_machine/object_protocol.rb", "lib/zerg_support/gems.rb", "lib/zerg_support/open_ssh.rb", "lib/zerg_support/process.rb", "lib/zerg_support/spawn.rb", "lib/zerg_support.rb", "LICENSE", "Manifest", "Rakefile", "README", "RUBYFORGE", "test/fork_tree.rb", "test/test_connection_mocks.rb", "test/test_frame_protocol.rb", "test/test_gems.rb", "test/test_object_protocol.rb", "test/test_open_ssh.rb", "test/test_process.rb", "test/test_spawn.rb", "zerg_support.gemspec"]
-  s.has_rdoc = true
+  s.extra_rdoc_files = ["CHANGELOG", "lib/zerg_support/event_machine/connection_mocks.rb", "lib/zerg_support/event_machine/protocol_adapter.rb", "lib/zerg_support/gems.rb", "lib/zerg_support/open_ssh.rb", "lib/zerg_support/process.rb", "lib/zerg_support/protocols/frame_protocol.rb", "lib/zerg_support/protocols/object_protocol.rb", "lib/zerg_support/socket_factory.rb", "lib/zerg_support/sockets/protocol_adapter.rb", "lib/zerg_support/sockets/socket_mocks.rb", "lib/zerg_support/spawn.rb", "lib/zerg_support.rb", "LICENSE", "README"]
+  s.files = ["CHANGELOG", "lib/zerg_support/event_machine/connection_mocks.rb", "lib/zerg_support/event_machine/protocol_adapter.rb", "lib/zerg_support/gems.rb", "lib/zerg_support/open_ssh.rb", "lib/zerg_support/process.rb", "lib/zerg_support/protocols/frame_protocol.rb", "lib/zerg_support/protocols/object_protocol.rb", "lib/zerg_support/socket_factory.rb", "lib/zerg_support/sockets/protocol_adapter.rb", "lib/zerg_support/sockets/socket_mocks.rb", "lib/zerg_support/spawn.rb", "lib/zerg_support.rb", "LICENSE", "Manifest", "Rakefile", "README", "RUBYFORGE", "test/fork_tree.rb", "test/test_connection_mocks.rb", "test/test_frame_protocol.rb", "test/test_gems.rb", "test/test_object_protocol.rb", "test/test_open_ssh.rb", "test/test_process.rb", "test/test_socket_factory.rb", "test/test_spawn.rb", "zerg_support.gemspec"]
   s.homepage = %q{http://www.zergling.net}
   s.rdoc_options = ["--line-numbers", "--inline-source", "--title", "Zerg_support", "--main", "README"]
   s.require_paths = ["lib"]
   s.rubyforge_project = %q{zerglings}
-  s.rubygems_version = %q{1.3.1}
+  s.rubygems_version = %q{1.3.4}
   s.summary = %q{Support libraries used by Zergling.Net deployment code.}
-  s.test_files = ["test/test_connection_mocks.rb", "test/test_frame_protocol.rb", "test/test_gems.rb", "test/test_object_protocol.rb", "test/test_open_ssh.rb", "test/test_process.rb", "test/test_spawn.rb"]
+  s.test_files = ["test/test_connection_mocks.rb", "test/test_frame_protocol.rb", "test/test_gems.rb", "test/test_object_protocol.rb", "test/test_open_ssh.rb", "test/test_process.rb", "test/test_socket_factory.rb", "test/test_spawn.rb"]
 
   if s.respond_to? :specification_version then
     current_version = Gem::Specification::CURRENT_SPECIFICATION_VERSION
-    s.specification_version = 2
+    s.specification_version = 3
 
     if Gem::Version.new(Gem::RubyGemsVersion) >= Gem::Version.new('1.2.0') then
       s.add_development_dependency(%q<echoe>, [">= 3.0.2"])

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: zerg_support
 version: !ruby/object:Gem::Version 
-  version: 0.0.9
+  version: "0.1"
 platform: ruby
 authors: 
 - Victor Costan
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2009-03-28 00:00:00 -04:00
+date: 2009-06-02 00:00:00 -04:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -51,11 +51,15 @@ extensions: []
 extra_rdoc_files: 
 - CHANGELOG
 - lib/zerg_support/event_machine/connection_mocks.rb
-- lib/zerg_support/event_machine/frame_protocol.rb
-- lib/zerg_support/event_machine/object_protocol.rb
+- lib/zerg_support/event_machine/protocol_adapter.rb
 - lib/zerg_support/gems.rb
 - lib/zerg_support/open_ssh.rb
 - lib/zerg_support/process.rb
+- lib/zerg_support/protocols/frame_protocol.rb
+- lib/zerg_support/protocols/object_protocol.rb
+- lib/zerg_support/socket_factory.rb
+- lib/zerg_support/sockets/protocol_adapter.rb
+- lib/zerg_support/sockets/socket_mocks.rb
 - lib/zerg_support/spawn.rb
 - lib/zerg_support.rb
 - LICENSE
@@ -63,11 +67,15 @@ extra_rdoc_files:
 files: 
 - CHANGELOG
 - lib/zerg_support/event_machine/connection_mocks.rb
-- lib/zerg_support/event_machine/frame_protocol.rb
-- lib/zerg_support/event_machine/object_protocol.rb
+- lib/zerg_support/event_machine/protocol_adapter.rb
 - lib/zerg_support/gems.rb
 - lib/zerg_support/open_ssh.rb
 - lib/zerg_support/process.rb
+- lib/zerg_support/protocols/frame_protocol.rb
+- lib/zerg_support/protocols/object_protocol.rb
+- lib/zerg_support/socket_factory.rb
+- lib/zerg_support/sockets/protocol_adapter.rb
+- lib/zerg_support/sockets/socket_mocks.rb
 - lib/zerg_support/spawn.rb
 - lib/zerg_support.rb
 - LICENSE
@@ -82,10 +90,13 @@ files:
 - test/test_object_protocol.rb
 - test/test_open_ssh.rb
 - test/test_process.rb
+- test/test_socket_factory.rb
 - test/test_spawn.rb
 - zerg_support.gemspec
 has_rdoc: true
 homepage: http://www.zergling.net
+licenses: []
+
 post_install_message: 
 rdoc_options: 
 - --line-numbers
@@ -111,9 +122,9 @@ required_rubygems_version: !ruby/object:Gem::Requirement
 requirements: []
 
 rubyforge_project: zerglings
-rubygems_version: 1.3.1
+rubygems_version: 1.3.4
 signing_key: 
-specification_version: 2
+specification_version: 3
 summary: Support libraries used by Zergling.Net deployment code.
 test_files: 
 - test/test_connection_mocks.rb
@@ -122,4 +133,5 @@ test_files:
 - test/test_object_protocol.rb
 - test/test_open_ssh.rb
 - test/test_process.rb
+- test/test_socket_factory.rb
 - test/test_spawn.rb