ichannel 5.2.0 → 6.0.0

data/.travis.yml

@@ -9,5 +9,8 @@ env:
   - SERIALIZER=Marshal
   - SERIALIZER=JSON
 
+services:
+  - redis-server
+
 notifications:
   email: true 

data/ChangeLog.txt

@@ -1,50 +1,65 @@
+== v0.6.0
+	- IChannel::UNIXSocket can now be serialized by Marshal.
+	IChannel::UNIXSocket can be serialized by Marshal but there's a gotcha: it
+	only really works on the same machine between one or more Ruby processes.
+	The UNIXSocket#marshal_dump method is implemented to dump the FDs in an array, 
+	so this feature won't fair well across different machines or time but I've 
+	found this feature useful nonetheless.
+
+	- add IChannel.unix(…)
+	Returns an instance of IChannel::UNIXSocket.
+
+	- add IChannel::UNIXSocket
+	rename IChannel as IChannel::UNIXSocket in preparation for multiple 
+	backends(UNIXSocket, Redis, …).
+
 == v5.2.0
-	* add IChannel#last_msg.
+	- add IChannel#last_msg.
 	Reads the last message written to the channel by reading until the channel
 	is empty. The last message is cached and reset to nil on call to #close.
 
 == v5.1.1.1, v5.1.1.2, v5.1.1.3, v5.1.1.4, v5.1.1.5
-	* doc improvements
+	- doc improvements
 	a set of releases that improved the README & api docs.
 
 == v5.1.1
-	* Change socket type to use TCP.
+	- Change socket type to use TCP.
 	The use of UDP could result in bugs because of its unordered nature.
 
 == v5.1.0
-	* Remove restriction on size of message.
+	- Remove restriction on size of message.
 	IChannel#get can read a message of any size(before hand it was limited to 
 	1MB in size). Thanks to @quezacoatl.
 
-	* IChannel#readable? no longer blocks.
+	- IChannel#readable? no longer blocks.
 	IChannel#readable? no longer blocks for 0.1 seconds on IO.select call.
 	Thanks to quezacoatl(https://github.com/quezacoatl) for the initial 
 	implementation. 
 
 == v5.0.0
-	* Remove IChannel#empty?
+	- Remove IChannel#empty?
 	I think the #readable? method is all you need, and is a much more 
 	accurate description of what the method is asking. We cannot determine
 	if the channel is really empty, but we can ask if it is readable at the 
 	time you ask.
 
 == v4.1.0
-	* Add IChannel#readable?
+	- Add IChannel#readable?
 	A method that can tell you whether or not a read would block. 
 	When it returns true, a read shouldn't block, on the other hand
 	if it were false it'd likely block by the time you call #get.
 
 == v4.0.0
-	* Modify IChannel#empty?
+	- Modify IChannel#empty?
 	It now returns true in case the underlying UNIXSocket being used as a 
 	reader is closed.
 
 == v3.1.0
-	* Add IChannel#empty?.
+	- Add IChannel#empty?.
 	IChannel#empty? returns true when the channel is empty(nothing to read).
 	
-	* Micro speed improvement on #write!, & #recv! operations.
+	- Micro speed improvement on #write!, & #recv! operations.
 	By passing nil instead of creating two empty arrays for every read/write 
 	operation we should see a very small improvement in their performance.
 
-	* Add ChangeLog.txt 
+	- Add ChangeLog.txt 

data/README.md

@@ -32,7 +32,7 @@ A demo of how to pass ruby objects through a channel and also between processes.
 in this example: 
 
 ```ruby
-channel = IChannel.new Marshal
+channel = IChannel.unix Marshal
 pid = fork do 
   channel.put Process.pid
   channel.put 'Hello!'
@@ -48,7 +48,7 @@ Knowing when a channel is readable can be useful so that you can avoid a
 blocking read. This (bad) example demonstrates how to do that:
 
 ```ruby
-channel = IChannel.new Marshal
+channel = IChannel.unix Marshal 
 pid = fork do
   sleep 3
   channel.put 42
@@ -75,7 +75,7 @@ module MyMessagePack
     MessagePack.unpack(msg)
   end
 end
-channel = IChannel.new MyMessagePack
+channel = IChannel.unix MyMessagePack
 ```
 
 __PLATFORM SUPPORT__

data/lib/ichannel/unix_socket.rb

@@ -0,0 +1,174 @@
+require 'socket'
+class IChannel
+  class UNIXSocket
+    SEP = '_$_'
+    if respond_to? :private_constant
+      private_constant :SEP
+    end
+
+    #
+    # @param [#dump,#load] serializer
+    #   Any object that implements dump, & load.
+    #
+    def initialize(serializer = Marshal, adapter_options)
+      @serializer = serializer
+      @last_msg = nil
+      @reader, @writer = ::UNIXSocket.pair :STREAM
+    end
+
+    #
+    # @return [Boolean]
+    #   Returns true when the channel is closed.
+    #
+    def closed?
+      @reader.closed? && @writer.closed?
+    end
+
+    #
+    # Close the channel.
+    #
+    # @return [Boolean]
+    #   Returns true when the channel has been closed.
+    #
+    def close
+      unless closed?
+        @reader.close
+        @writer.close
+        @last_msg = nil
+        true
+      end
+    end
+
+    #
+    # Add an object to the channel.
+    #
+    # @raise [IOError]
+    #   When the channel is closed.
+    #
+    # @param [Object] object
+    #   An object to add to the channel.
+    #
+    def write(object)
+      write!(object, nil)
+    end
+    alias_method :put, :write
+
+    #
+    # Add an object to the channel.
+    #
+    # Unlike {#write}, which waits indefinitely until the channel becomes writable,
+    # this method will raise an IOError when _timeout_ seconds elapse and
+    # the channel remains unwritable.
+    #
+    # @param
+    #   (see IChannel#write)
+    #
+    # @param [Numeric] timeout
+    #   The number of seconds to wait for the channel to become writable.
+    #
+    # @raise (see IChannel#write)
+    #
+    # @raise [IOError]
+    #   When _timeout_ seconds elapse & the channel remains unwritable.
+    #
+    def write!(object, timeout = 0.1)
+      if @writer.closed?
+        raise IOError, 'The channel cannot be written to (closed).'
+      end
+      _, writable, _ = IO.select nil, [@writer], nil, timeout
+      if writable
+        msg = @serializer.dump(object)
+        writable[0].syswrite "#{msg}#{SEP}"
+      else
+        raise IOError, 'The channel cannot be written to.'
+      end
+    end
+    alias_method :put!, :write!
+
+    #
+    # Reads the last message written to the channel by reading until the channel
+    # is empty. The last message is cached and reset to nil on call to {#close}.
+    #
+    # @return [Object]
+    #   Returns the last message to be written to the channel.
+    #
+    def last_msg
+      while readable?
+        @last_msg = get
+      end
+      @last_msg
+    end
+
+    #
+    # Receive an object from the channel.
+    #
+    # @raise [IOError]
+    #   When the channel is closed.
+    #
+    # @return [Object]
+    #   The object read from the channel.
+    #
+    def recv
+      recv!(nil)
+    end
+    alias_method :get, :recv
+
+    #
+    # Receive an object from the channel.
+    #
+    # Unlike {#recv}, which waits indefinitely until the channel becomes readable,
+    # this method will raise an IOError when _timeout_ seconds elapse and the
+    # channel remains unreadable.
+    #
+    # @param [Numeric] timeout
+    #   The number of seconds to wait for the channel to become readable.
+    #
+    # @raise [IOError]
+    #   (see IChannel#recv)
+    #
+    # @raise [IOError]
+    #   When _timeout_ seconds elapse & the channel remains unreadable.
+    #
+    # @return [Object]
+    #   The object read from the channel.
+    #
+    def recv!(timeout = 0.1)
+      if @reader.closed?
+        raise IOError, 'The channel cannot be read from (closed).'
+      end
+      readable, _ = IO.select [@reader], nil, nil, timeout
+      if readable
+        msg = readable[0].readline(SEP).chomp SEP
+        @serializer.load msg
+      else
+        raise IOError, 'The channel cannot be read from.'
+      end
+    end
+    alias_method :get!, :recv!
+
+    #
+    # @return [Boolean]
+    #   Returns true when the channel is readable.
+    #
+    def readable?
+      if closed?
+        false
+      else
+        readable, _ = IO.select [@reader], nil, nil, 0
+        !! readable
+      end
+    end
+
+    # @api private
+    def marshal_load(array)
+      @serializer, reader, writer, @last_msg = array
+      @reader = ::UNIXSocket.for_fd(reader)
+      @writer = ::UNIXSocket.for_fd(writer)
+    end
+
+    # @api private
+    def marshal_dump
+      [@serializer, @reader.to_i, @writer.to_i, @last_msg]
+    end
+  end
+end

data/lib/ichannel/version.rb

@@ -1,3 +1,3 @@
 class IChannel
-  VERSION = "5.2.0"
+  VERSION = "6.0.0"
 end

data/lib/ichannel.rb

@@ -1,159 +1,11 @@
-require 'socket'
 class IChannel
-  SEP = '_$_'
-  if respond_to? :private_constant
-    private_constant :SEP
-  end
-  #
-  # @param [#dump,#load] serializer
-  #   Any object that implements dump, & load.
-  #
-  def initialize(serializer)
-    @reader, @writer = UNIXSocket.pair :STREAM
-    @serializer = serializer
-    @last_msg = nil
-  end
-
-  #
-  # @return [Boolean]
-  #   Returns true when the channel is closed.
-  #
-  def closed?
-    @reader.closed? && @writer.closed?
-  end
-
-  #
-  # Close the channel.
-  #
-  # @return [Boolean]
-  #   Returns true when the channel has been closed.
-  #
-  def close
-    unless closed?
-      @reader.close
-      @writer.close
-      @last_msg = nil
-      true
-    end
-  end
-
-  #
-  # Add an object to the channel.
-  #
-  # @raise [IOError]
-  #   When the channel is closed.
-  #
-  # @param [Object] object
-  #   An object to add to the channel.
-  #
-  def write(object)
-    write!(object, nil)
-  end
-  alias_method :put, :write
-
-  #
-  # Add an object to the channel.
-  #
-  # Unlike {#write}, which waits indefinitely until the channel becomes writable,
-  # this method will raise an IOError when _timeout_ seconds elapse and
-  # the channel remains unwritable.
-  #
-  # @param
-  #   (see IChannel#write)
-  #
-  # @param [Numeric] timeout
-  #   The number of seconds to wait for the channel to become writable.
-  #
-  # @raise (see IChannel#write)
-  #
-  # @raise [IOError]
-  #   When _timeout_ seconds elapse & the channel remains unwritable.
-  #
-  def write!(object, timeout = 0.1)
-    if @writer.closed?
-      raise IOError, 'The channel cannot be written to (closed).'
-    end
-    _, writable, _ = IO.select nil, [@writer], nil, timeout
-    if writable
-      msg = @serializer.dump(object)
-      writable[0].syswrite "#{msg}#{SEP}"
-    else
-      raise IOError, 'The channel cannot be written to.'
-    end
-  end
-  alias_method :put!, :write!
-
-  #
-  # Reads the last message written to the channel by reading until the channel
-  # is empty. The last message is cached and reset to nil on call to {#close}.
-  #
-  # @return [Object]
-  #   Returns the last message to be written to the channel.
-  #
-  def last_msg
-    while readable?
-      @last_msg = get
-    end
-    @last_msg
-  end
-
-  #
-  # Receive an object from the channel.
-  #
-  # @raise [IOError]
-  #   When the channel is closed.
-  #
-  # @return [Object]
-  #   The object read from the channel.
-  #
-  def recv
-    recv!(nil)
-  end
-  alias_method :get, :recv
+  require_relative "ichannel/unix_socket"
 
-  #
-  # Receive an object from the channel.
-  #
-  # Unlike {#recv}, which waits indefinitely until the channel becomes readable,
-  # this method will raise an IOError when _timeout_ seconds elapse and the
-  # channel remains unreadable.
-  #
-  # @param [Numeric] timeout
-  #   The number of seconds to wait for the channel to become readable.
-  #
-  # @raise [IOError]
-  #   (see IChannel#recv)
-  #
-  # @raise [IOError]
-  #   When _timeout_ seconds elapse & the channel remains unreadable.
-  #
-  # @return [Object]
-  #   The object read from the channel.
-  #
-  def recv!(timeout = 0.1)
-    if @reader.closed?
-      raise IOError, 'The channel cannot be read from (closed).'
-    end
-    readable, _ = IO.select [@reader], nil, nil, timeout
-    if readable
-      msg = readable[0].readline(SEP).chomp SEP
-      @serializer.load msg
-    else
-      raise IOError, 'The channel cannot be read from.'
-    end
+  def self.unix(options)
+    UNIXSocket.new(options)
   end
-  alias_method :get!, :recv!
 
-  #
-  # @return [Boolean]
-  #   Returns true when the channel is readable.
-  #
-  def readable?
-    if closed?
-      false
-    else
-      readable, _ = IO.select [@reader], nil, nil, 0
-      !! readable
-    end
+  def self.redis(options)
+    raise NotImplementedError
   end
 end

data/test/ichannel_class_test.rb

@@ -2,13 +2,36 @@ require_relative 'setup'
 class IChannelTest < Test::Unit::TestCase
   def setup
     serializer = Object.const_get ENV["SERIALIZER"] || "Marshal"
-    @channel = IChannel.new serializer
+    @channel = IChannel.unix serializer
   end
 
   def teardown
     @channel.close
   end
 
+  def test_interface
+    %w(write
+    write!
+    get
+    get!
+    close
+    closed?
+    readable?
+    last_msg
+    put
+    put!
+    recv
+    recv!).each do |method|
+      assert @channel.respond_to? method
+    end
+  end
+
+  def test_serialization
+    @channel.put 42
+    dump = Marshal.dump @channel
+    assert_equal 42, Marshal.load(dump).get
+  end
+
   def test_last_msg
     @channel.put %w(a)
     @channel.put %w(b)

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: ichannel
 version: !ruby/object:Gem::Version
-  version: 5.2.0
+  version: 6.0.0
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-04-05 00:00:00.000000000 Z
+date: 2013-04-20 00:00:00.000000000 Z
 dependencies: []
 description: ! "A modern and easy-to-use interprocess communication \n    primitive."
 email:
@@ -29,6 +29,7 @@ files:
 - Rakefile
 - ichannel.gemspec
 - lib/ichannel.rb
+- lib/ichannel/unix_socket.rb
 - lib/ichannel/version.rb
 - test/ichannel_class_test.rb
 - test/setup.rb
@@ -46,7 +47,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: '0'
       segments:
       - 0
-      hash: 1696570348195705541
+      hash: -4148613930352415051
 required_rubygems_version: !ruby/object:Gem::Requirement
   none: false
   requirements:
@@ -55,7 +56,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
       segments:
       - 0
-      hash: 1696570348195705541
+      hash: -4148613930352415051
 requirements: []
 rubyforge_project: 
 rubygems_version: 1.8.23