win32-ipc 0.5.0

data/CHANGES

@@ -0,0 +1,44 @@
+== 0.5.0 - 30-Apr-2007
+* Now pure Ruby.
+* Ipc.new no longer accepts a block.
+* Changed IpcError to Ipc::Error.
+* Removed the 'doc' directory.  The documentation is now inlined via rdoc.
+* Added a gemspec.
+* Added a Rakefile, including tasks for installation and testing.
+
+== 0.4.1 - 23-Jan-2005
+* Minor internal modifications for handling block arguments.
+
+== 0.4.0 - 16-Dec-2004
+* Changed the timeout from milliseconds to seconds.  This wasn't documented,
+  and I'm guessing most people didn't know that they were passing milliseconds
+  instead of seconds.  But, I've bumped the version number, just in case.
+
+== 0.3.1 - 11-Dec-2004
+* Fixed a bug in Ipc#wait where a segfault would occur if a block was not
+  provided.
+* Moved the 'examples' directory to the toplevel directory.
+
+== 0.3.0 - 31-Oct-2004
+* The constructor now takes an optional block.  Instance objects will call
+  that block if they are signaled.
+* Added the 'block' method (read-only).  Allows you to access the block
+  provided to the constructor.
+* Modified the 'wait' instance method to take an optional block.  This block
+  will be called if the object is signaled.  Overrides the block to the
+  constructor for that instance object (only).
+* Added the 'signaled?' instance method to indicate if the object is in the
+  signaled state or not.
+* Modified all methods to raise an IpcError if an error occurs (instead of
+  simply returning nil).
+* Added internal comments in order to make the code rdoc friendly, including
+  changes to the README file.
+
+== 0.2.0 - 15-Jul-2004
+* Updated to use the newer allocation framework.  This means that as of
+  version 0.2.0, this package requires Ruby 1.8.0 or later.
+* Moved the test.rb script to docs/examples.
+* Minor code cleanup
+
+== 0.1.0 - 30-Apr-2004
+* Initial release

data/MANIFEST

@@ -0,0 +1,7 @@
+* CHANGES
+* install.rb
+* MANIFEST
+* README
+* win32-ipc.gemspec
+* lib/win32/ipc.rb
+* test/tc_ipc.rb

data/README

@@ -0,0 +1,34 @@
+= Description
+An abstract base class for Windows synchronization objects.
+
+= Installation
+rake test (optional)
+rake install
+   
+= Synopsis
+There is no synopsis. Don't use this module directly. It is used as the basis
+for other packages, such as win32-mutex, etc.
+
+= Notes
+Based originally on the Win32::Ipc module by Gurusamy Sarathy.
+
+This package 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
+
+= License
+Ruby's
+    
+= Copyright
+(C) 2003-2007 Daniel J. Berger, All Rights Reserved
+    
+= Warranty
+This package is provided "as is" and without any express or
+implied warranties, including, without limitation, the implied
+warranties of merchantability and fitness for a particular purpose.
+	
+= Authors
+* Park Heesob
+* Daniel J. Berger

data/Rakefile

@@ -0,0 +1,14 @@
+require 'rake'
+require 'rake/testtask'
+
+desc 'Install the win32-ipc package (non-gem)'
+task :install do
+   ruby 'install.rb'
+end
+
+Rake::TestTask.new do |t|
+   t.libs << 'test'
+   t.verbose = true
+   t.warning = true
+   t.test_files = FileList['test/tc_ipc.rb']
+end

data/install.rb

@@ -0,0 +1,11 @@
+# For those who don't like gems...
+require 'rbconfig'
+require 'fileutils'
+include Config
+
+sitelibdir = CONFIG['sitelibdir']
+installdir = sitelibdir + '/win32'
+file = 'lib\win32\ipc.rb'
+
+Dir.mkdir(installdir) unless File.exists?(installdir)
+FileUtils.cp(file, installdir, :verbose => true)

data/lib/win32/ipc.rb

@@ -0,0 +1,150 @@
+require 'windows/error'
+require 'windows/synchronize'
+require 'windows/handle'
+
+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
+
+      VERSION = '0.5.0'
+
+      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
+      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.
+      #
+      def signaled?
+         @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 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
+      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)
+      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
+         
+         length = ipc_objects.length
+         
+         if length == 0
+            raise Error, 'no objects to wait for'
+         end
+         
+         wait = WaitForMultipleObjects(length, ipc_objects, 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_0) && (wait < WAIT_ABANDONED_0 + length)
+            return -wait - WAIT_ABANDONED_0 + 1
+         end
+         
+         # timed out
+         return 0 if wait == WAIT_TIMEOUT
+         
+         nil
+      end
+   end
+end

data/test/tc_ipc.rb

@@ -0,0 +1,74 @@
+##########################################################################
+# tc_ipc.rb
+#
+# Test case for the Win32::Ipc class.  Note that this class is rather
+# difficult to test directly since it is meant to be subclassed, not
+# used directly.
+#
+# You should run this test via the 'rake test' task.
+##########################################################################
+require 'win32/ipc'
+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.0', Ipc::VERSION)
+   end
+   
+   def test_handle
+      assert_respond_to(@ipc, :handle)
+      assert_equal(1, @ipc.handle)
+   end
+   
+   def test_signaled
+      assert_respond_to(@ipc, :signaled?)
+      assert_equal(false, @ipc.signaled?)
+   end
+   
+   def test_wait
+      assert_respond_to(@ipc, :wait)
+   end
+   
+   def test_wait_expected_errors
+      assert_raises(Ipc::Error){ @ipc.wait }
+      assert_raises(ArgumentError){ @ipc.wait(1,2) }
+   end
+   
+   def test_wait_any
+      assert_respond_to(@ipc, :wait_any)
+   end
+   
+   def test_wait_any_expected_errors
+      assert_raises(Ipc::Error){ @ipc.wait_any([]) }
+      assert_raises(TypeError){ @ipc.wait_any(1,2) }
+   end
+   
+   def test_wait_all
+      assert_respond_to(@ipc, :wait_all)
+   end
+   
+   def test_wait_all_expected_errors
+      assert_raises(Ipc::Error){ @ipc.wait_all([]) }
+      assert_raises(TypeError){ @ipc.wait_all(1,2) }
+   end
+   
+   def test_close
+      assert_respond_to(@ipc, :close)
+      assert_nothing_raised{ @ipc.close }
+   end
+   
+   def test_constants
+      assert_not_nil(Ipc::SIGNALED)
+      assert_not_nil(Ipc::ABANDONED)
+      assert_not_nil(Ipc::TIMEOUT)
+   end
+   
+   def teardown
+      @ipc = nil
+   end
+end

data/win32-ipc.gemspec

@@ -0,0 +1,24 @@
+require "rubygems"
+
+spec = Gem::Specification.new do |gem|
+   gem.name        = "win32-ipc"
+   gem.version     = "0.5.0"
+   gem.author      = "Daniel J. Berger"
+   gem.email       = "djberg96@gmail.com"
+   gem.homepage    = "http://www.rubyforge.org/projects/win32utils"
+   gem.platform    = Gem::Platform::RUBY
+   gem.summary     = "An abstract base class for Windows synchronization objects."
+   gem.description = "An abstract base class for Windows synchronization objects."
+   gem.test_file   = "test/tc_ipc.rb"
+   gem.has_rdoc    = true
+   gem.files       = Dir["lib/win32/*.rb"] + Dir["test/*"] + Dir["[A-Z]*"]
+   gem.files.reject! { |fn| fn.include? "CVS" }
+   gem.require_path = "lib"
+   gem.extra_rdoc_files = ["README", "CHANGES", "MANIFEST"]
+   gem.add_dependency("windows-pr", ">= 0.6.0")
+end
+
+if $0 == __FILE__
+   Gem.manage_gems
+   Gem::Builder.new(spec).build
+end

metadata

@@ -0,0 +1,67 @@
+--- !ruby/object:Gem::Specification 
+rubygems_version: 0.9.0.8
+specification_version: 1
+name: win32-ipc
+version: !ruby/object:Gem::Version 
+  version: 0.5.0
+date: 2007-04-30 00:00:00 -06:00
+summary: An abstract base class for Windows synchronization objects.
+require_paths: 
+- lib
+email: djberg96@gmail.com
+homepage: http://www.rubyforge.org/projects/win32utils
+rubyforge_project: 
+description: An abstract base class for Windows synchronization objects.
+autorequire: 
+default_executable: 
+bindir: bin
+has_rdoc: true
+required_ruby_version: !ruby/object:Gem::Version::Requirement 
+  requirements: 
+  - - ">"
+    - !ruby/object:Gem::Version 
+      version: 0.0.0
+  version: 
+platform: ruby
+signing_key: 
+cert_chain: 
+post_install_message: 
+authors: 
+- Daniel J. Berger
+files: 
+- lib/win32/ipc.rb
+- test/CVS
+- test/tc_ipc.rb
+- CHANGES
+- CVS
+- install.rb
+- lib
+- MANIFEST
+- Rakefile
+- README
+- test
+- win32-ipc.gemspec
+test_files: 
+- test/tc_ipc.rb
+rdoc_options: []
+
+extra_rdoc_files: 
+- README
+- CHANGES
+- MANIFEST
+executables: []
+
+extensions: []
+
+requirements: []
+
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: windows-pr
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Version::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 0.6.0
+    version: