win32-pipe 0.2.2 → 0.3.0

data/lib/win32/pipe/client.rb

@@ -1,65 +1,65 @@
-# The Win32 module serves as a namespace only
-module Win32
-
-  # The Pipe::Client class encapsulates the client side of a named pipe
-  # connection.
-  #
-  class Pipe::Client < Pipe
-
-    # Create and return a new Pipe::Client instance. The +name+, +pipe_mode+,
-    # and +open_mode+ are passed to the Win32::Pipe superclass.
-    #
-    # The default +pipe_mode+ is NOWAIT.
-    #
-    # The default +open_mode+ is FILE_ATTRIBUTE_NORMAL | FILE_FLAG_WRITE_THROUGH.
-    #
-    # In block form the client object is yield, and is automatically
-    # disconnected and closed at the end of the block.
-    #
-    # Example:
-    #
-    #   require 'win32/pipe'
-    #
-    #   Pipe::Client.new('foo') do |pipe|
-    #     puts "Connected..."
-    #     pipe.write("Ruby rocks!")
-    #     data = pipe.read
-    #     puts "Got [#{data}] back from pipe server"
-    #  end
-    #
-    def initialize(name, pipe_mode = DEFAULT_PIPE_MODE, open_mode = DEFAULT_OPEN_MODE)
-      super(name, pipe_mode, open_mode)
-         
-      @pipe = CreateFile(
-        @name,
-        GENERIC_READ | GENERIC_WRITE,
-        FILE_SHARE_READ | FILE_SHARE_WRITE,
-        nil,
-        OPEN_EXISTING,
-        @open_mode,
-        nil 
-      )
-
-      error = GetLastError()
-         
-      if error == ERROR_PIPE_BUSY
-        unless WaitNamedPipe(@name, NMPWAIT_WAIT_FOREVER)
-          raise Error, get_last_error
-        end
-      end
-         
-      if @pipe == INVALID_HANDLE_VALUE
-        raise Error, get_last_error
-      end
-         
-      if block_given?
-        begin
-          yield self
-        ensure
-          disconnect
-          close
-        end
-      end
-    end
-  end
-end
+# The Win32 module serves as a namespace only
+module Win32
+
+  # The Pipe::Client class encapsulates the client side of a named pipe
+  # connection.
+  #
+  class Pipe::Client < Pipe
+
+    # Create and return a new Pipe::Client instance. The +name+, +pipe_mode+,
+    # and +open_mode+ are passed to the Win32::Pipe superclass.
+    #
+    # The default +pipe_mode+ is NOWAIT.
+    #
+    # The default +open_mode+ is FILE_ATTRIBUTE_NORMAL | FILE_FLAG_WRITE_THROUGH.
+    #
+    # In block form the client object is yield, and is automatically
+    # disconnected and closed at the end of the block.
+    #
+    # Example:
+    #
+    #   require 'win32/pipe'
+    #
+    #   Pipe::Client.new('foo') do |pipe|
+    #     puts "Connected..."
+    #     pipe.write("Ruby rocks!")
+    #     data = pipe.read
+    #     puts "Got [#{data}] back from pipe server"
+    #  end
+    #
+    def initialize(name, pipe_mode = DEFAULT_PIPE_MODE, open_mode = DEFAULT_OPEN_MODE)
+      super(name, pipe_mode, open_mode)
+
+      @pipe = CreateFile(
+        @name,
+        GENERIC_READ | GENERIC_WRITE,
+        FILE_SHARE_READ | FILE_SHARE_WRITE,
+        nil,
+        OPEN_EXISTING,
+        @open_mode,
+        0
+      )
+
+      error = GetLastError()
+
+      if error == ERROR_PIPE_BUSY
+        unless WaitNamedPipe(@name, NMPWAIT_WAIT_FOREVER)
+          raise SystemCallError.new("WaitNamedPipe", FFI.errno)
+        end
+      end
+
+      if @pipe == INVALID_HANDLE_VALUE
+        raise SystemCallError.new("CreateFile", error)
+      end
+
+      if block_given?
+        begin
+          yield self
+        ensure
+          disconnect
+          close
+        end
+      end
+    end
+  end
+end

data/lib/win32/pipe/server.rb

@@ -1,96 +1,96 @@
-# The Win32 module serves as a namespace only.
-module Win32
-   # The Pipe::Server class encapsulates the server side of a named pipe
-   # connection.
-   class Pipe::Server < Pipe
-   
-      # Creates and returns a new Pipe::Server instance, using +name+ as the
-      # name for the pipe. Note that this does not actually connect the pipe.
-      # Use Pipe::Server#connect for that.
-      #
-      # The default pipe_mode is PIPE_TYPE_BYTE | PIPE_READMODE_BYTE | PIPE_WAIT.
-      #
-      # The default open_mode is Pipe::ACCESS_DUPLEX.
-      #--
-      # The default pipe_mode also happens to be 0.
-      # 
-      def initialize(name, pipe_mode = 0, open_mode = Pipe::ACCESS_DUPLEX)
-         super(name, pipe_mode, open_mode)
-         
-         @pipe = CreateNamedPipe(
-            @name,
-            @open_mode,
-            @pipe_mode,
-            PIPE_UNLIMITED_INSTANCES,
-            PIPE_BUFFER_SIZE,
-            PIPE_BUFFER_SIZE,
-            PIPE_TIMEOUT,
-            0
-         )
-         
-         if @pipe == INVALID_HANDLE_VALUE
-            raise Error, get_last_error
-         end
-
-         if block_given?
-            begin
-               yield self
-            ensure
-               close
-            end
-         end
-      end
-      
-      # Enables the named pipe server process to wait for a client process
-      # to connect to an instance of a named pipe. In other words, it puts
-      # the server in 'connection wait' status.
-      #
-      # In synchronous mode always returns true on success. In asynchronous
-      # mode returns true if there is pending IO, or false otherwise.
-      # 
-      def connect
-         if @asynchronous
-            # An overlapped ConnectNamedPipe should return 0
-            if ConnectNamedPipe(@pipe, @overlapped)
-               raise Error, get_last_error
-            end
-            
-            error = GetLastError()
-
-            case error
-               when ERROR_IO_PENDING
-                  @pending_io = true
-               when ERROR_PIPE_CONNECTED
-                  unless SetEvent(@event)
-                     raise Error, get_last_error(error)
-                  end
-               when ERROR_PIPE_LISTENING
-                  # Do nothing
-               else
-                  raise Error, get_last_error(error)
-            end
-
-            if @pending_io
-               return false
-            else
-               return true
-            end
-         else
-            unless ConnectNamedPipe(@pipe, nil)
-               raise Error, get_last_error
-            end
-         end
-
-         return true
-      end
-      
-      # Close the server. This will flush file buffers, disconnect the
-      # pipe, and close the pipe handle.
-      #
-      def close
-         FlushFileBuffers(@pipe)
-         DisconnectNamedPipe(@pipe)
-         super
-      end
-   end
-end
+# The Win32 module serves as a namespace only.
+module Win32
+  # The Pipe::Server class encapsulates the server side of a named pipe
+  # connection.
+  class Pipe::Server < Pipe
+
+    # Creates and returns a new Pipe::Server instance, using +name+ as the
+    # name for the pipe. Note that this does not actually connect the pipe.
+    # Use Pipe::Server#connect for that.
+    #
+    # The default pipe_mode is PIPE_TYPE_BYTE | PIPE_READMODE_BYTE | PIPE_WAIT.
+    #
+    # The default open_mode is Pipe::ACCESS_DUPLEX.
+    #--
+    # The default pipe_mode also happens to be 0.
+    #
+    def initialize(name, pipe_mode = 0, open_mode = Pipe::ACCESS_DUPLEX)
+      super(name, pipe_mode, open_mode)
+
+      @pipe = CreateNamedPipe(
+        @name,
+        @open_mode,
+        @pipe_mode,
+        PIPE_UNLIMITED_INSTANCES,
+        PIPE_BUFFER_SIZE,
+        PIPE_BUFFER_SIZE,
+        PIPE_TIMEOUT,
+        nil
+      )
+
+      if @pipe == INVALID_HANDLE_VALUE
+        raise
+      end
+
+      if block_given?
+        begin
+          yield self
+        ensure
+          close
+        end
+      end
+    end
+
+    # Enables the named pipe server process to wait for a client process
+    # to connect to an instance of a named pipe. In other words, it puts
+    # the server in 'connection wait' status.
+    #
+    # In synchronous mode always returns true on success. In asynchronous
+    # mode returns true if there is pending IO, or false otherwise.
+    #
+    def connect
+      if @asynchronous
+        # An overlapped ConnectNamedPipe should return 0
+        if ConnectNamedPipe(@pipe, @overlapped)
+          raise SystemCallError.new("ConnectNamedPipe", FFI.errno)
+        end
+
+        error = GetLastError()
+
+        case error
+          when ERROR_IO_PENDING
+            @pending_io = true
+          when ERROR_PIPE_CONNECTED
+            unless SetEvent(@event)
+              raise Error, get_last_error(error)
+            end
+          when ERROR_PIPE_LISTENING
+            # Do nothing
+          else
+            raise Error, get_last_error(error)
+        end
+
+        if @pending_io
+          return false
+        else
+          return true
+        end
+      else
+        unless ConnectNamedPipe(@pipe, nil)
+          raise SystemCallError.new("ConnectNamedPipe", FFI.errno)
+        end
+      end
+
+      return true
+    end
+
+    # Close the server. This will flush file buffers, disconnect the
+    # pipe, and close the pipe handle.
+    #
+    def close
+      FlushFileBuffers(@pipe)
+      DisconnectNamedPipe(@pipe)
+      super
+    end
+  end
+end

data/lib/win32/pipe/windows/constants.rb

@@ -0,0 +1,37 @@
+module Windows
+  module Constants
+    PIPE_WAIT             = 0x00000000
+    PIPE_NOWAIT           = 0x00000001
+    PIPE_ACCESS_INBOUND   = 0x00000001
+    PIPE_ACCESS_OUTBOUND  = 0x00000002
+    PIPE_ACCESS_DUPLEX    = 0x00000003
+    PIPE_TYPE_BYTE        = 0x00000000
+    PIPE_TYPE_MESSAGE     = 0x00000004
+    PIPE_READMODE_BYTE    = 0x00000000
+    PIPE_READMODE_MESSAGE = 0x00000002
+    PIPE_CLIENT_END       = 0x00000000
+    PIPE_SERVER_END       = 0x00000001
+
+    PIPE_UNLIMITED_INSTANCES = 255
+
+    FILE_FLAG_OVERLAPPED = 0x40000000
+    FILE_FLAG_FIRST_PIPE_INSTANCE = 0x00080000
+    FILE_FLAG_WRITE_THROUGH       = 0x80000000
+    FILE_ATTRIBUTE_NORMAL        = 0x00000080
+
+    INFINITE = 0xFFFFFFFF
+    INVALID_HANDLE_VALUE = 0xFFFFFFFF
+    NMPWAIT_WAIT_FOREVER = 0xFFFFFFFF
+    ERROR_PIPE_BUSY = 231
+    ERROR_IO_PENDING = 997
+
+    WAIT_TIMEOUT = 0x102
+    WAIT_OBJECT_0 = 0
+
+    GENERIC_READ  = 0x80000000
+    GENERIC_WRITE = 0x40000000
+    FILE_SHARE_READ  = 1
+    FILE_SHARE_WRITE = 2
+    OPEN_EXISTING    = 3
+  end
+end

data/lib/win32/pipe/windows/functions.rb

@@ -0,0 +1,31 @@
+require 'ffi'
+
+module Windows
+  module Functions
+    extend FFI::Library
+    ffi_lib :kernel32
+
+    module FFI::Library
+      # Wrapper method for attach_function + private
+      def attach_pfunc(*args)
+        attach_function(*args)
+        private args[0]
+      end
+    end
+
+    attach_pfunc :CloseHandle, [:ulong], :bool
+    attach_pfunc :ConnectNamedPipe, [:ulong, :pointer], :bool
+    attach_pfunc :CreateEvent, :CreateEventA, [:pointer, :bool, :bool, :string], :ulong
+    attach_pfunc :CreateFile, :CreateFileA, [:string, :ulong, :ulong, :pointer, :ulong, :ulong, :ulong], :ulong
+    attach_pfunc :CreateNamedPipe, :CreateNamedPipeA, [:string, :ulong, :ulong, :ulong, :ulong, :ulong, :ulong, :pointer], :ulong
+    attach_pfunc :CreatePipe, [:pointer, :pointer, :pointer, :ulong], :bool
+    attach_pfunc :DisconnectNamedPipe, [:ulong], :bool
+    attach_pfunc :FlushFileBuffers, [:ulong], :bool
+    attach_pfunc :GetLastError, [], :ulong
+    attach_pfunc :GetOverlappedResult, [:ulong, :pointer, :pointer, :bool], :bool
+    attach_pfunc :ReadFile, [:ulong, :buffer_out, :ulong, :pointer, :pointer], :bool
+    attach_pfunc :WaitForSingleObject, [:ulong, :ulong], :ulong
+    attach_pfunc :WaitNamedPipe, :WaitNamedPipeA, [:string, :ulong], :bool
+    attach_pfunc :WriteFile, [:ulong, :buffer_in, :ulong, :pointer, :pointer], :bool
+  end
+end

data/test/test_win32_pipe.rb

@@ -1,126 +1,162 @@
-##########################################################################
-# test_win32_pipe.rb
-#
-# Test suite for the win32-pipe library. This test suite should be run
-# via the 'rake test' task.
-##########################################################################
-require 'rubygems'
-gem 'test-unit'
-require 'test/unit'
-
-require 'win32/pipe'
-include Win32
-
-class TC_Win32_Pipe < Test::Unit::TestCase
-  def setup
-    @pipe = Pipe.new('foo')
-  end
-   
-  def test_version
-    assert_equal('0.2.2', Pipe::VERSION)
-  end
-
-  def test_name
-    assert_respond_to(@pipe, :name)
-    assert_nothing_raised{ @pipe.name }
-    assert_equal("\\\\.\\pipe\\foo", @pipe.name)
-  end
-
-  def test_pipe_mode
-    assert_respond_to(@pipe, :pipe_mode)
-    assert_nothing_raised{ @pipe.pipe_mode }
-    assert_equal(Pipe::DEFAULT_PIPE_MODE, @pipe.pipe_mode)
-  end
-
-  def test_open_mode
-    assert_respond_to(@pipe, :open_mode)
-    assert_nothing_raised{ @pipe.open_mode }
-    assert_equal(Pipe::DEFAULT_OPEN_MODE, @pipe.open_mode)
-  end
- 
-  def test_buffer
-    assert_respond_to(@pipe, :buffer)
-    assert_nothing_raised{ @pipe.buffer }
-  end
- 
-  def test_size
-    assert_respond_to(@pipe, :size)
-    assert_nothing_raised{ @pipe.size }
-  end
- 
-  def test_length_alias
-    assert_respond_to(@pipe, :length)
-    assert_true(@pipe.method(:length) == @pipe.method(:size))
-    assert_alias_method(@pipe, :length, :size)
-  end
- 
-  def test_pending
-    assert_respond_to(@pipe, :pending?)
-    assert_nothing_raised{ @pipe.pending? }
-    assert_false(@pipe.pending?)
-  end
-
-  def test_asynchronous
-    assert_respond_to(@pipe, :asynchronous?)
-    assert_nothing_raised{ @pipe.asynchronous? }
-    assert_false(@pipe.asynchronous?)
-  end
- 
-  def test_read
-    assert_respond_to(@pipe, :read)
-    assert_raises(Pipe::Error){ @pipe.read } # Nothing to read
-  end
- 
-  def test_transferred
-    assert_respond_to(@pipe, :transferred)
-    assert_nothing_raised{ @pipe.transferred }
-  end
- 
-  def test_wait
-    assert_respond_to(@pipe, :wait)
-    assert_raises(Pipe::Error){ @pipe.wait } # Can't wait in blocking mode
-  end
- 
-  def test_write
-    assert_respond_to(@pipe, :write)
-    assert_raises(ArgumentError){ @pipe.write }      # Must have 1 argument
-    assert_raises(Pipe::Error){ @pipe.write("foo") } # Nothing to write to
-  end
-
-  def test_disconnect
-    assert_respond_to(@pipe, :disconnect)
-    assert_nothing_raised{ @pipe.disconnect }
-  end
-
-  def test_close
-    assert_respond_to(@pipe, :close)
-    assert_nothing_raised{ @pipe.close }
-  end
- 
-  def test_pipe_mode_constants
-    assert_not_nil(Pipe::WAIT)
-    assert_not_nil(Pipe::NOWAIT)
-    assert_not_nil(Pipe::TYPE_BYTE)
-    assert_not_nil(Pipe::TYPE_MESSAGE)
-    assert_not_nil(Pipe::READMODE_BYTE)
-    assert_not_nil(Pipe::READMODE_MESSAGE)
-  end
-
-  def test_open_mode_constants
-    assert_not_nil(Pipe::ACCESS_DUPLEX)
-    assert_not_nil(Pipe::ACCESS_INBOUND)
-    assert_not_nil(Pipe::ACCESS_OUTBOUND)
-    assert_not_nil(Pipe::FIRST_PIPE_INSTANCE)
-    assert_not_nil(Pipe::WRITE_THROUGH)
-    assert_not_nil(Pipe::OVERLAPPED)
-  end
-
-  def test_other_constants
-    assert_not_nil(Pipe::INFINITE)
-  end
- 
-  def teardown
-    @pipe.close
-    @pipe = nil
-  end
-end
+##########################################################################
+# test_win32_pipe.rb
+#
+# Test suite for the win32-pipe library. This test suite should be run
+# via the 'rake test' task.
+##########################################################################
+require 'test-unit'
+require 'win32/pipe'
+include Win32
+
+class TC_Win32_Pipe < Test::Unit::TestCase
+  def setup
+    @pipe = Pipe.new('foo')
+  end
+
+  test "version is set to expected value" do
+    assert_equal('0.3.0', Pipe::VERSION)
+  end
+
+  test "name method basic functionality" do
+    assert_respond_to(@pipe, :name)
+    assert_nothing_raised{ @pipe.name }
+    assert_kind_of(String, @pipe.name)
+  end
+
+  test "name returns expected string" do
+    assert_equal("\\\\.\\pipe\\foo", @pipe.name)
+  end
+
+  test "mode method basic functionality" do
+    assert_respond_to(@pipe, :pipe_mode)
+    assert_nothing_raised{ @pipe.pipe_mode }
+    assert_kind_of(Fixnum, @pipe.pipe_mode)
+  end
+
+  test "mode method returns expected value" do
+    assert_equal(Pipe::DEFAULT_PIPE_MODE, @pipe.pipe_mode)
+  end
+
+  test "open_mode basic functionality" do
+    assert_respond_to(@pipe, :open_mode)
+    assert_nothing_raised{ @pipe.open_mode }
+    assert_kind_of(Numeric, @pipe.open_mode)
+  end
+
+  test "open_mode returns the expected value" do
+    assert_equal(Pipe::DEFAULT_OPEN_MODE, @pipe.open_mode)
+  end
+
+  test "buffer method basic functionality" do
+    assert_respond_to(@pipe, :buffer)
+    assert_nothing_raised{ @pipe.buffer }
+  end
+
+  test "size basic functionality" do
+    assert_respond_to(@pipe, :size)
+    assert_nothing_raised{ @pipe.size }
+  end
+
+  test "length is an alias for size" do
+    assert_respond_to(@pipe, :length)
+    assert_alias_method(@pipe, :length, :size)
+  end
+
+  test "pending method basic functionality" do
+    assert_respond_to(@pipe, :pending?)
+    assert_nothing_raised{ @pipe.pending? }
+    assert_boolean(@pipe.pending?)
+  end
+
+  test "pending method defaults to false" do
+    assert_false(@pipe.pending?)
+  end
+
+  test "asynchronous method basic functionality" do
+    assert_respond_to(@pipe, :asynchronous?)
+    assert_nothing_raised{ @pipe.asynchronous? }
+    assert_boolean(@pipe.asynchronous?)
+  end
+
+  test "asynchronous method defaults to false" do
+    assert_false(@pipe.asynchronous?)
+  end
+
+  test "read method basic functionality" do
+    assert_respond_to(@pipe, :read)
+  end
+
+  test "read method raises an error if there's nothing to read" do
+    assert_raises(Pipe::Error){ @pipe.read }
+  end
+
+  test "transfered method basic functionality" do
+    assert_respond_to(@pipe, :transferred)
+    assert_nothing_raised{ @pipe.transferred }
+  end
+
+  test "wait method basic functionality" do
+    assert_respond_to(@pipe, :wait)
+  end
+
+  test "wait method raises an error in blocking mode" do
+    assert_raises(Pipe::Error){ @pipe.wait }
+  end
+
+  test "write method basic functionality" do
+    assert_respond_to(@pipe, :write)
+  end
+
+  test "write method requires one argument" do
+    assert_raises(ArgumentError){ @pipe.write }
+  end
+
+  test "write method raises an error if there's nothing to write to" do
+    assert_raises(Pipe::Error){ @pipe.write("foo") }
+  end
+
+  test "disconnect method basic functionality" do
+    assert_respond_to(@pipe, :disconnect)
+    assert_nothing_raised{ @pipe.disconnect }
+  end
+
+  test "calling the disconnect method multiple times has no effect" do
+    assert_nothing_raised{ @pipe.disconnect; @pipe.disconnect }
+  end
+
+  test "close method basic functionality" do
+    assert_respond_to(@pipe, :close)
+    assert_nothing_raised{ @pipe.close }
+  end
+
+  test "calling close multiple times has no effect" do
+    assert_nothing_raised{ @pipe.close; @pipe.close }
+  end
+
+  test "pipe_mode constants" do
+    assert_not_nil(Pipe::WAIT)
+    assert_not_nil(Pipe::NOWAIT)
+    assert_not_nil(Pipe::TYPE_BYTE)
+    assert_not_nil(Pipe::TYPE_MESSAGE)
+    assert_not_nil(Pipe::READMODE_BYTE)
+    assert_not_nil(Pipe::READMODE_MESSAGE)
+  end
+
+  test "open_mode constants" do
+    assert_not_nil(Pipe::ACCESS_DUPLEX)
+    assert_not_nil(Pipe::ACCESS_INBOUND)
+    assert_not_nil(Pipe::ACCESS_OUTBOUND)
+    assert_not_nil(Pipe::FIRST_PIPE_INSTANCE)
+    assert_not_nil(Pipe::WRITE_THROUGH)
+    assert_not_nil(Pipe::OVERLAPPED)
+  end
+
+  test "other contants" do
+    assert_not_nil(Pipe::INFINITE)
+  end
+
+  def teardown
+    @pipe.close if @pipe
+    @pipe = nil
+  end
+end