win32-ipc 0.5.3 → 0.6.0

data/CHANGES

@@ -1,3 +1,11 @@
+== 0.6.0 - 8-Jul-2012
+* Now uses FFI instead of win32-api.
+* The #signaled? method now has a meaningful default implementation.
+* If an internal C function fails it raises a SystemCallError (Errno) instead
+  of an Ipc::Error.
+* The Ipc::Error class, although defined for those who wish to still use it
+  in inherited classes, is no longer used internally.
+
 == 0.5.3 - 19-Apr-2010
 * Added a few gem related tasks to the Rakefile, and removed an old install
   task.

data/README

@@ -6,7 +6,7 @@ gem install win32-ipc
    
 = Synopsis
 There is no synopsis. Don't use this module directly. It is used as the basis
-for other libraries, such as win32-mutex, etc.
+for other libraries, such as win32-mutex, etc. Think of it as an interface.
 
 = Notes
 Originally based on the Win32::Ipc Perl module by Gurusamy Sarathy.
@@ -14,14 +14,14 @@ Originally based on the Win32::Ipc Perl module by Gurusamy Sarathy.
 This library is a prerequisite for several other IPC related Windows packages.
 
 = Known Bugs
-None that I know of. Please log any other bug reports on the RubyForge
-project page at http://www.rubyforge.net/projects/win32utils
+None that I know of. Please log any other bug reports on the project page
+at https://github.com/djberg96/win32-ipc.
 
 = License
 Artistic 2.0
     
 = Copyright
-(C) 2003-2010 Daniel J. Berger, All Rights Reserved
+(C) 2003-2012 Daniel J. Berger, All Rights Reserved
     
 = Warranty
 This package is provided "as is" and without any express or

data/Rakefile

@@ -1,14 +1,10 @@
 require 'rake'
 require 'rake/testtask'
-require 'rbconfig'
-include Config
+require 'rake/clean'
 
-namespace 'gem' do
-  desc 'Delete any .gem files in the current directory'
-  task :clean do
-    Dir['*.gem'].each{ |f| File.delete(f) }
-  end
+CLEAN.include("**/*.gem", "**/*.rbc")
 
+namespace 'gem' do
   desc 'Create the win32-ipc gem'
   task :create => [:clean] do
     spec = eval(IO.read('win32-ipc.gemspec')) 
@@ -23,6 +19,8 @@ namespace 'gem' do
 end
 
 Rake::TestTask.new do |t|
-   t.verbose = true
-   t.warning = true
+  t.verbose = true
+  t.warning = true
 end
+
+task :default => :test

data/lib/win32/ipc.rb

@@ -1,159 +1,182 @@
-require 'windows/error'
-require 'windows/synchronize'
-require 'windows/handle'
+require 'ffi'
 
 # The Win32 module serves as a namespace only.
 module Win32
 
-   # This is a an abstract base class for IPC related classes, such as
-   # Events and Semaphores.
-   #
-   class Ipc
-      include Windows::Error
-      include Windows::Synchronize
-      include Windows::Handle
-
-      class Error < StandardError; end
-
-      # The version of the win32-ipc library
-      VERSION = '0.5.3'
-
-      SIGNALED  = 1
-      ABANDONED = -1
-      TIMEOUT   = 0
-      
-      # The HANDLE object (an unsigned long value).  Mostly provided for
-      # subclasses to use internally when needed.
-      # 
-      attr_reader :handle
-
-      # Creates and returns a new IPC object.  Since the IPC class is meant
-      # as an abstract base class, you should never call this method directly.
-      #
-      def initialize(handle)
-         @handle   = handle
-         @signaled = false
+  # This is a an abstract base class for IPC related classes, such as
+  # Events and Semaphores.
+  #
+  class Ipc
+    extend FFI::Library
+    ffi_lib :kernel32
+
+    attach_function :CloseHandle, [:ulong], :bool
+    attach_function :WaitForSingleObject, [:ulong, :ulong], :ulong
+    attach_function :WaitForMultipleObjects, [:ulong, :pointer, :bool, :ulong], :ulong
+
+    private_class_method :CloseHandle, :WaitForSingleObject, :WaitForMultipleObjects
+
+    # The version of the win32-ipc library
+    VERSION = '0.6.0'
+
+    SIGNALED  = 1
+    ABANDONED = -1
+    TIMEOUT   = 0
+    INFINITE  = 0xFFFFFFFF
+
+    WAIT_OBJECT_0    = 0
+    WAIT_TIMEOUT     = 0x102
+    WAIT_ABANDONED   = 128
+    WAIT_ABANDONED_0 = WAIT_ABANDONED
+    WAIT_FAILED      = 0xFFFFFFFF
+
+    # The HANDLE object (an unsigned long value).  Mostly provided for
+    # subclasses to use internally when needed.
+    #
+    attr_reader :handle
+
+    # Creates and returns a new IPC object.  Since the IPC class is meant
+    # as an abstract base class, you should never call this method directly.
+    #
+    def initialize(handle)
+      @handle   = handle
+      @signaled = false
+    end
+
+    # Closes the handle object provided in the constructor.
+    #
+    def close
+      CloseHandle(@handle)
+    end
+
+    # Returns whether or not the IPC object is in a signaled state.
+    #--
+    # This method assumes a single object. You may need to redefine this
+    # to suit your needs in your subclass.
+    #
+    def signaled?
+      state = WaitForSingleObject(@handle, 0)
+
+      if state == WAIT_FAILED
+        raise SystemCallError.new("WaitForSingleObject", FFI.errno)
+      elsif state == WAIT_OBJECT_0
+        @signaled = true
+      else
+        @signaled = false
       end
-      
-      # Closes the handle object provided in the constructor.
-      # 
-      def close
-         CloseHandle(@handle)
+
+      @signaled
+    end
+
+    # call-seq:
+    #   Ipc#wait(timeout)
+    #   Ipc#wait(timeout){ block called when signaled }
+    #
+    # Waits for the calling object to be signaled.  The +timeout+ value is
+    # the maximum time to wait, in seconds. A timeout of 0 returns immediately.
+    #
+    # Returns SIGNALED (1), ABANDONED (-1) or TIMEOUT (0). Raises a
+    # SystemCallError (Errno) if the wait fails for some reason.
+    #
+    def wait(timeout = INFINITE)
+      timeout *= 1000 if timeout && timeout != INFINITE
+
+      wait = WaitForSingleObject(@handle, timeout)
+
+      case wait
+        when WAIT_FAILED
+          raise SystemCallError.new("WaitForSingleObject", FFI.errno)
+        when WAIT_OBJECT_0
+          @signaled = true
+          yield if block_given?
+          return SIGNALED
+        when WAIT_ABANDONED
+          return ABANDONED
+        when WAIT_TIMEOUT
+          return TIMEOUT
+        else
+          raise SystemCallError.new("WaitForSingleObject", FFI.errno)
       end
+    end
 
-      # Returns whether or not the IPC object is in a signaled state.
-      #
-      def signaled?
-         @signaled
+    # :call-seq:
+    #   IPC#wait_any([ipc_objects], timeout = INFINITE)
+    #
+    # Waits for at least one of the +ipc_objects+ to be signaled. The
+    # +timeout+ value is maximum time to wait in seconds. A timeout of 0
+    # returns immediately.
+    #
+    # Returns the index+1 of the object that was signaled. If multiple
+    # objects are signaled, the one with the lowest index is returned.
+    # Returns 0 if no objects are signaled.
+    #
+    def wait_any(ipc_objects, timeout=INFINITE)
+      timeout *= 1000 if timeout && timeout != INFINITE
+      wait_for_multiple(ipc_objects, 0, timeout)
+    end
+
+    # :call-seq:
+    #   IPC#wait_all([ipc_objects], timeout = INFINITE)
+    #
+    # Identical to IPC#wait_any, except that it waits for all +ipc_objects+
+    # to be signaled instead of just one.
+    #
+    # Returns the index of the last object signaled. If at least one of the
+    # objects is an abandoned mutex, the return value is negative.
+    #
+    def wait_all(ipc_objects, timeout=INFINITE)
+      timeout *= 1000 if timeout && timeout != INFINITE
+      wait_for_multiple(ipc_objects, 1, timeout)
+    end
+
+    private
+
+    # Waits until one or all (depending on the value of +wait_all+) of the
+    # +ipc_objects+ are in the signaled state or the +timeout+ interval
+    # elapses.
+    #
+    def wait_for_multiple(ipc_objects, wait_all=0, timeout=INFINITE)
+      unless ipc_objects.is_a?(Array)
+        msg = 'invalid argument - must be an array of Ipc objects'
+        raise TypeError, msg
       end
-      
-      # call-seq:
-      #    Ipc#wait(timeout)
-      #    Ipc#wait(timeout){ block called when signaled }
-      #
-      # Waits for the calling object to be signaled.  The +timeout+ value is
-      # the maximum time to wait, in seconds.  A timeout of 0 returns
-      # immediately.
-      #
-      # Returns SIGNALED (1), ABANDONED (-1) or TIMEOUT (0).  Raises an
-      # IPC::Error if the wait fails for some reason.
-      # 
-      def wait(timeout = INFINITE)
-         timeout *= 1000 if timeout && timeout != INFINITE
-
-         wait = WaitForSingleObject(@handle, timeout)
-         
-         case wait
-            when WAIT_FAILED
-               raise Error, get_last_error
-            when WAIT_OBJECT_0
-               @signaled = true
-               yield if block_given?
-               return SIGNALED
-            when WAIT_ABANDONED
-               return ABANDONED
-            when WAIT_TIMEOUT
-               return TIMEOUT
-            else
-               raise Error, get_last_error
-         end
+
+      length = ipc_objects.length
+
+      if length == 0
+        raise ArgumentError, 'no objects to wait for'
       end
-      
-      # :call-seq:
-      #    IPC#wait_any([ipc_objects], timeout = INFINITE)
-      #
-      # Waits for at least one of the +ipc_objects+ to be signaled.  The
-      # +timeout+ value is maximum time to wait in seconds.  A timeout of 0
-      # returns immediately.
-      #
-      # Returns the index+1 of the object that was signaled.  If multiple
-      # objects are signaled, the one with the lowest index is returned.
-      # Returns 0 if no objects are signaled.
-      # 
-      def wait_any(ipc_objects, timeout=INFINITE)
-         timeout *= 1000 if timeout && timeout != INFINITE
-         wait_for_multiple(ipc_objects, 0, timeout)
+
+      ptr = FFI::MemoryPointer.new(:ulong, ipc_objects.size)
+
+      handles = ipc_objects.map{ |o| o.handle }
+      ptr.write_array_of_ulong(handles)
+
+      wait = WaitForMultipleObjects(
+        length,
+        ptr,
+        wait_all,
+        timeout
+      )
+
+      if wait == WAIT_FAILED
+        raise SystemCallError.new("WaitForMultipleObjects", FFI.errno)
       end
-      
-      # :call-seq:
-      #    IPC#wait_all([ipc_objects], timeout = INFINITE)
-      #
-      # Identical to IPC#wait_any, except that it waits for all +ipc_objects+
-      # to be signaled instead of just one.
-      #
-      # Returns the index of the last object signaled.  If at least one of the
-      # objects is an abandoned mutex, the return value is negative.
-      # 
-      def wait_all(ipc_objects, timeout=INFINITE)
-         timeout *= 1000 if timeout && timeout != INFINITE
-         wait_for_multiple(ipc_objects, 1, timeout)
+
+      # signaled
+      if (wait >= WAIT_OBJECT_0) && (wait < WAIT_OBJECT_0 + length)
+        return wait - WAIT_OBJECT_0 + 1
       end
-      
-      private
-      
-      # Waits until one or all (depending on the value of +wait_all+) of the
-      # +ipc_objects+ are in the signaled state or the +timeout+ interval
-      # elapses. 
-      #
-      def wait_for_multiple(ipc_objects, wait_all=0, timeout=INFINITE)
-         unless ipc_objects.is_a?(Array)
-            msg = 'invalid argument - must be an array of Ipc objects'
-            raise TypeError, msg
-         end
-         
-         length = ipc_objects.length
-         
-         if length == 0
-            raise Error, 'no objects to wait for'
-         end
-         
-         handles = ipc_objects.map{ |o| o.handle }
-
-         wait = WaitForMultipleObjects(
-            length,
-            handles.pack('L*'),
-            wait_all,
-            timeout
-         )
-         
-         if wait == WAIT_FAILED
-            raise Error, get_last_error
-         end
-         
-         # signaled
-         if (wait >= WAIT_OBJECT_0) && (wait < WAIT_OBJECT_0 + length)
-            return wait - WAIT_OBJECT_0 + 1
-         end
-         
-         # abandoned mutex - return negative value
-         if (wait >= WAIT_ABANDONED) && (wait < WAIT_ABANDONED + length)
-            return -wait - WAIT_ABANDONED + 1
-         end
-         
-         # timed out
-         return 0 if wait == WAIT_TIMEOUT
-         
-         nil
+
+      # abandoned mutex - return negative value
+      if (wait >= WAIT_ABANDONED) && (wait < WAIT_ABANDONED + length)
+        return -wait - WAIT_ABANDONED + 1
       end
-   end
+
+      # timed out
+      return 0 if wait == WAIT_TIMEOUT
+
+      nil
+    end
+  end
 end

data/test/test_win32_ipc.rb

@@ -8,66 +8,80 @@
 # You should run this test via the 'rake test' task.
 ##########################################################################
 require 'win32/ipc'
-require 'test/unit'
+require 'test-unit'
 include Win32
 
 class TC_Win32_Ipc < Test::Unit::TestCase
   def setup
     @ipc = Ipc.new(1)
   end
-   
-  def test_version
-    assert_equal('0.5.3', Ipc::VERSION)
+
+  test "version is set to expected value" do
+    assert_equal('0.6.0', Ipc::VERSION)
   end
-   
-  def test_handle
+
+  test "handle method basic functionality" do
     assert_respond_to(@ipc, :handle)
     assert_equal(1, @ipc.handle)
   end
-   
-  def test_signaled
+
+  test "signaled? method is defined" do
     assert_respond_to(@ipc, :signaled?)
-    assert_equal(false, @ipc.signaled?)
   end
-   
-  def test_wait
+
+  test "wait method is defined" do
     assert_respond_to(@ipc, :wait)
   end
-   
-  def test_wait_expected_errors
-    assert_raises(Ipc::Error){ @ipc.wait }
+
+  test "wait raises ENXIO if handle is invalid" do
+    assert_raises(Errno::ENXIO){ @ipc.wait }
+  end
+
+  test "wait accepts a maximum of one argument" do
     assert_raises(ArgumentError){ @ipc.wait(1,2) }
   end
-   
-  def test_wait_any
+
+  test "wait_any method is defined" do
     assert_respond_to(@ipc, :wait_any)
   end
-   
-  def test_wait_any_expected_errors
-    assert_raises(Ipc::Error){ @ipc.wait_any([]) }
+
+  test "wait_any raises an ArgumentError if the array is empty" do
+    assert_raises(ArgumentError){ @ipc.wait_any([]) }
+  end
+
+  test "wait_any only accepts an array" do
     assert_raises(TypeError){ @ipc.wait_any(1,2) }
   end
-   
-  def test_wait_all
+
+  test "wait_all method is defined" do
     assert_respond_to(@ipc, :wait_all)
   end
-   
-  def test_wait_all_expected_errors
-    assert_raises(Ipc::Error){ @ipc.wait_all([]) }
+
+  test "wait_all raises an ArgumentError if the array is empty" do
+    assert_raises(ArgumentError){ @ipc.wait_all([]) }
+  end
+
+  test "wait_all only accepts an array" do
     assert_raises(TypeError){ @ipc.wait_all(1,2) }
   end
-   
-  def test_close
+
+  test "close method basic functionality" do
     assert_respond_to(@ipc, :close)
     assert_nothing_raised{ @ipc.close }
   end
-   
-  def test_constants
+
+  test "expected constants are defined" do
     assert_not_nil(Ipc::SIGNALED)
     assert_not_nil(Ipc::ABANDONED)
     assert_not_nil(Ipc::TIMEOUT)
   end
-   
+
+  test "ffi functions are private" do
+    assert_not_respond_to(Ipc, :CloseHandle)
+    assert_not_respond_to(Ipc, :WaitForSingleObject)
+    assert_not_respond_to(Ipc, :WaitForMultipleObjects)
+  end
+
   def teardown
     @ipc = nil
   end

data/win32-ipc.gemspec

@@ -2,21 +2,20 @@ require 'rubygems'
 
 Gem::Specification.new do |spec|
   spec.name      = 'win32-ipc'
-  spec.version   = '0.5.3'
+  spec.version   = '0.6.0'
   spec.authors   = ['Daniel J. Berger', 'Park Heesob']
   spec.license   = 'Artistic 2.0'
   spec.email     = 'djberg96@gmail.com'
   spec.homepage  = 'http://www.rubyforge.org/projects/win32utils'
-  spec.platform  = Gem::Platform::RUBY
   spec.summary   = 'An abstract base class for Windows synchronization objects.'
   spec.test_file = 'test/test_win32_ipc.rb'
-  spec.has_rdoc  = true
   spec.files     = Dir['**/*'].reject{ |f| f.include?('git') }
 
   spec.extra_rdoc_files  = ['README', 'CHANGES', 'MANIFEST']
   spec.rubyforge_project = 'win32utils'
 
-  spec.add_dependency('windows-pr', '>= 1.0.6')
+  spec.add_dependency('ffi')
+  spec.add_development_dependency('test-unit')
 
   spec.description = <<-EOF
     The win32-ipc library provides the Win32::IPC class. This is meant to

metadata

@@ -1,39 +1,60 @@
---- !ruby/object:Gem::Specification 
+--- !ruby/object:Gem::Specification
 name: win32-ipc
-version: !ruby/object:Gem::Version 
-  version: 0.5.3
+version: !ruby/object:Gem::Version
+  version: 0.6.0
+  prerelease: 
 platform: ruby
-authors: 
+authors:
 - Daniel J. Berger
 - Park Heesob
 autorequire: 
 bindir: bin
 cert_chain: []
-
-date: 2010-04-19 00:00:00 -06:00
-default_executable: 
-dependencies: 
-- !ruby/object:Gem::Dependency 
-  name: windows-pr
+date: 2012-07-09 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: ffi
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
   type: :runtime
-  version_requirement: 
-  version_requirements: !ruby/object:Gem::Requirement 
-    requirements: 
-    - - ">="
-      - !ruby/object:Gem::Version 
-        version: 1.0.6
-    version: 
-description: "    The win32-ipc library provides the Win32::IPC class. This is meant to\n    serve as an abstract base class for other IPC related libraries for MS\n    Windows, such as win32-semaphore, win32-event, and so on.\n"
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: test-unit
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: ! "    The win32-ipc library provides the Win32::IPC class. This is meant
+  to\n    serve as an abstract base class for other IPC related libraries for MS\n
+  \   Windows, such as win32-semaphore, win32-event, and so on.\n"
 email: djberg96@gmail.com
 executables: []
-
 extensions: []
-
-extra_rdoc_files: 
+extra_rdoc_files:
 - README
 - CHANGES
 - MANIFEST
-files: 
+files:
 - CHANGES
 - lib/win32/ipc.rb
 - MANIFEST
@@ -41,33 +62,30 @@ files:
 - README
 - test/test_win32_ipc.rb
 - win32-ipc.gemspec
-has_rdoc: true
 homepage: http://www.rubyforge.org/projects/win32utils
-licenses: 
+licenses:
 - Artistic 2.0
 post_install_message: 
 rdoc_options: []
-
-require_paths: 
+require_paths:
 - lib
-required_ruby_version: !ruby/object:Gem::Requirement 
-  requirements: 
-  - - ">="
-    - !ruby/object:Gem::Version 
-      version: "0"
-  version: 
-required_rubygems_version: !ruby/object:Gem::Requirement 
-  requirements: 
-  - - ">="
-    - !ruby/object:Gem::Version 
-      version: "0"
-  version: 
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
 requirements: []
-
 rubyforge_project: win32utils
-rubygems_version: 1.3.5
+rubygems_version: 1.8.23
 signing_key: 
 specification_version: 3
 summary: An abstract base class for Windows synchronization objects.
-test_files: 
+test_files:
 - test/test_win32_ipc.rb