celluloid-io 0.17.2 → 0.17.3

data/lib/celluloid/io/udp_socket.rb

@@ -1,12 +1,27 @@
 module Celluloid
   module IO
     # UDPSockets with combined blocking and evented support
-    class UDPSocket
+    class UDPSocket < Socket
       extend Forwardable
-      def_delegators :@socket, :addr, :bind, :connect, :send, :recvfrom_nonblock, :close, :closed?
+      def_delegators :to_io, :bind, :connect, :send, :recvfrom_nonblock
 
-      def initialize(address_family = ::Socket::AF_INET)
-        @socket = ::UDPSocket.new(address_family)
+      # @overload initialize(address_family)
+      #   Opens a new udp socket using address_family.
+      #   @param address_family [Numeric]
+      #
+      # @overload initialize(socket)
+      #   Wraps an already existing udp socket.
+      #   @param socket [::UDPSocket]
+      def initialize(*args)
+        if args.first.kind_of? ::BasicSocket
+          # socket
+          socket = args.first
+          fail ArgumentError, "wrong number of arguments (#{args.size} for 1)" if args.size != 1
+          fail ArgumentError, "wrong kind of socket (#{socket.class} for UDPSocket)" unless socket.kind_of? ::UDPSocket
+          super(socket)
+        else
+          super(::UDPSocket.new(*args))
+        end
       end
 
       # Wait until the socket is readable
@@ -16,13 +31,14 @@ module Celluloid
       # MSG_ options. The first element of the results, mesg, is the data
       # received. The second element, sender_addrinfo, contains
       # protocol-specific address information of the sender.
-      def recvfrom(maxlen, flags = nil)
+      def recvfrom(maxlen, flags = 0)
         begin
-          if @socket.respond_to? :recvfrom_nonblock
-            @socket.recvfrom_nonblock(maxlen, flags)
+          socket = to_io
+          if socket.respond_to? :recvfrom_nonblock
+            socket.recvfrom_nonblock(maxlen, flags)
           else
             # FIXME: hax for JRuby
-            @socket.recvfrom(maxlen, flags)
+            socket.recvfrom(maxlen, flags)
           end
         rescue ::IO::WaitReadable
           wait_readable
@@ -30,7 +46,6 @@ module Celluloid
         end
       end
 
-      def to_io; @socket; end
     end
   end
 end

data/lib/celluloid/io/unix_server.rb

@@ -3,40 +3,48 @@ require 'socket'
 module Celluloid
   module IO
     # UNIXServer with combined blocking and evented support
-    class UNIXServer
+    class UNIXServer < Socket
       extend Forwardable
-      def_delegators :@server, :listen, :sysaccept, :close, :closed?
+      def_delegators :to_io, :listen, :sysaccept
 
       def self.open(socket_path)
         self.new(socket_path)
       end
 
-      def initialize(socket_path)
-        begin
-          @server = ::UNIXServer.new(socket_path)
-        rescue => ex
-          # Translate the EADDRINUSE jRuby exception.
-          raise unless RUBY_PLATFORM == 'java'
-          if ex.class.name == "IOError" && # Won't agree to .is_a?(IOError)
-             ex.message.include?("in use")
-            raise Errno::EADDRINUSE.new(ex.message)
+      # @overload initialize(socket_path)
+      #   @param socket_path [String]
+      #
+      # @overload initialize(socket)
+      #   @param socket [::UNIXServer]
+      def initialize(socket)
+        if socket.kind_of? ::BasicSocket
+          # socket
+          fail ArgumentError, "wrong kind of socket (#{socket.class} for UNIXServer)" unless socket.kind_of? ::UNIXServer
+          super(socket)
+        else
+          begin
+            super(::UNIXServer.new(socket))
+          rescue => ex
+            # Translate the EADDRINUSE jRuby exception.
+            raise unless RUBY_PLATFORM == 'java'
+            if ex.class.name == "IOError" && # Won't agree to .is_a?(IOError)
+               ex.message.include?("in use")
+              raise Errno::EADDRINUSE.new(ex.message)
+            end
+            raise
           end
-          raise
         end
       end
 
       def accept
-        Celluloid::IO.wait_readable(@server)
+        Celluloid::IO.wait_readable(to_io)
         accept_nonblock
       end
 
       def accept_nonblock
-        Celluloid::IO::UNIXSocket.new(@server.accept_nonblock)
+        Celluloid::IO::UNIXSocket.new(to_io.accept_nonblock)
       end
 
-      def to_io
-        @server
-      end
     end
   end
 end

data/lib/celluloid/io/unix_socket.rb

@@ -4,10 +4,6 @@ module Celluloid
   module IO
     # UNIXSocket with combined blocking and evented support
     class UNIXSocket < Stream
-      extend Forwardable
-
-      def_delegators :@socket, :read_nonblock, :write_nonblock, :close, :closed?, :readline, :puts, :addr
-
       # Open a UNIX connection.
       def self.open(socket_path, &block)
         new(socket_path, &block)
@@ -15,31 +11,27 @@ module Celluloid
 
       # Convert a Ruby UNIXSocket into a Celluloid::IO::UNIXSocket
       # DEPRECATED: to be removed in a future release
+      # @deprecated use .new instead
       def self.from_ruby_socket(ruby_socket)
         new(ruby_socket)
       end
 
       # Open a UNIX connection.
       def initialize(socket_path, &block)
-        super()
-
         # Allow users to pass in a Ruby UNIXSocket directly
         if socket_path.is_a? ::UNIXSocket
-          @socket = socket_path
+          super(socket_path)
           return
         end
 
         # FIXME: not doing non-blocking connect
-        @socket = if block
-                    ::UNIXSocket.open(socket_path, &block)
-                  else
-                    ::UNIXSocket.new(socket_path)
+        if block
+          super ::UNIXSocket.open(socket_path, &block)
+        else
+          super ::UNIXSocket.new(socket_path)
         end
       end
 
-      def to_io
-        @socket
-      end
     end
   end
 end

data/lib/celluloid/io/version.rb

@@ -1,5 +1,5 @@
 module Celluloid
   module IO
-    VERSION = "0.17.2"
+    VERSION = "0.17.3"
   end
 end

data/spec/celluloid/io/actor_spec.rb

@@ -1,5 +1,58 @@
 require "spec_helper"
 
 RSpec.describe Celluloid::IO, library: :IO do
-  it_behaves_like "a Celluloid Actor", Celluloid::IO
+  it_behaves_like "a Celluloid Actor", Celluloid::IO do
+    let(:example_port) { assign_port }
+
+    context :timeouts do
+      let :sleeping_actor_class do
+        Class.new do
+          include Celluloid::IO
+          def initialize(addr, port)
+            @server = Celluloid::IO::TCPServer.new(addr, port)
+            async { @server.accept ; sleep 10 }
+          end
+        end
+      end
+      let :foo_actor_class do
+        Class.new do
+          include Celluloid::IO
+          def initialize(addr, port)
+            @sock = Celluloid::IO::TCPSocket.new(addr, port)
+          end
+
+          # returns true if the operation timedout
+          def timedout_read(duration)
+            begin 
+              timeout(duration) do
+                @sock.wait_readable
+              end
+            rescue Celluloid::TaskTimeout
+              return true
+            end
+            false
+          end
+ 
+          # returns true if it cannot write (socket is already registered)
+          def failed_write
+            begin
+              @sock.wait_readable
+            rescue ArgumentError # IO Selector Exception
+              return true
+            end
+            false
+          end
+        end
+      end
+
+      it "frees up the socket when a timeout error occurs" do
+        a1 = sleeping_actor_class.new(example_addr, example_port)
+        a2 = foo_actor_class.new(example_addr, example_port)
+      
+        expect(a2.timedout_read(1)).to eq true # this ensures that the socket timeouted trying to read
+        skip "not implemented"
+        expect(a2.failed_write).to eq false # this ensures that the socket isn't usable anymore
+      end
+    end
+  end
 end

data/spec/celluloid/io/socket_spec.rb

@@ -0,0 +1,173 @@
+require "spec_helper"
+
+RSpec.describe Celluloid::IO::Socket, library: :IO do
+  let(:logger) { Specs::FakeLogger.current }
+  let(:example_port) { assign_port }
+
+  context '.try_convert' do
+
+    subject{ described_class.try_convert(socket) }
+
+    after(:each) do
+      if subject.respond_to? :close
+        subject.close
+      else
+        socket.close if socket.respond_to? :close
+      end
+    end
+
+    context 'with a Celluloid Socket' do
+      let(:socket){ Celluloid::IO::UDPSocket.new }
+
+      it 'returns given socket' do
+        expect(subject).to be socket
+      end
+    end
+
+    context 'with a ::TCPServer' do
+      let(:socket){ ::TCPServer.new(example_port) }
+
+      it 'creates a Celluloid::IO::TCPServer' do
+        expect(subject).to be_a Celluloid::IO::TCPServer
+      end
+    end
+
+    context 'with a ::TCPSocket' do
+      let!(:server){
+        ::TCPServer.new example_addr, example_port
+      }
+      after(:each){
+        server.close
+      }
+
+      let(:socket){
+        ::TCPSocket.new example_addr, example_port
+      }
+
+      it 'creates a Celluloid::IO::TCPSocket' do
+        expect(subject).to be_a Celluloid::IO::TCPSocket
+      end
+    end
+
+    context 'with a ::UDPSocket' do
+      let(:socket){ ::UDPSocket.new }
+
+      it 'creates a Celluloid::IO::UDPServer' do
+        expect(subject).to be_a Celluloid::IO::UDPSocket
+      end
+    end
+
+    context 'with a ::UNIXServer' do
+      let(:socket){ ::UNIXServer.new(example_unix_sock) }
+
+      it 'creates a Celluloid::IO::UNIXServer' do
+        expect(subject).to be_a Celluloid::IO::UNIXServer
+      end
+    end
+
+    context 'with a ::UNIXSocket' do
+      let!(:server){
+        ::UNIXServer.new(example_unix_sock)
+      }
+      after(:each){
+        server.close
+      }
+
+      let(:socket){
+        ::UNIXSocket.new example_unix_sock
+      }
+
+      it 'creates a Celluloid::IO::UNIXSocket' do
+        expect(subject).to be_a Celluloid::IO::UNIXSocket
+      end
+    end
+
+    context 'with an OpenSSL::SSL::SSLServer' do
+      let(:socket){
+        OpenSSL::SSL::SSLServer.new(::TCPServer.new(example_addr, example_port), OpenSSL::SSL::SSLContext.new)
+      }
+
+      it 'creates a Celluloid::IO::SSLServer' do
+        expect(subject).to be_a Celluloid::IO::SSLServer
+      end
+    end
+
+    context 'with an OpenSSL::SSL::SSLSocket' do
+      let!(:server){
+        OpenSSL::SSL::SSLServer.new(::TCPServer.new(example_addr, example_port), OpenSSL::SSL::SSLContext.new)
+      }
+      after(:each){
+        server.close
+      }
+
+      let(:socket){
+        OpenSSL::SSL::SSLSocket.new(::TCPSocket.new(example_addr, example_port))
+      }
+
+     it 'creates a Celluloid::IO::SSLSocket' do
+        expect(subject).to be_a Celluloid::IO::SSLSocket
+      end
+    end
+
+    context 'with an object responding to #to_io' do
+      let(:real){
+        ::UDPSocket.new
+      }
+
+      let(:socket){
+        proxy = double(:socket)
+        allow(proxy).to receive(:to_io){ real }
+        allow(proxy).to receive(:close){ real.close }
+        proxy
+      }
+
+      it 'creates a celluloid socket' do
+        expect(subject).to be_a described_class
+      end
+
+      it 'uses the returned IO' do
+        expect(subject.to_io).to be socket.to_io
+      end
+    end
+
+    context 'with a simple object' do
+      let(:socket){ Object.new }
+
+      it 'returns nil' do
+        expect(subject).to be_nil
+      end
+    end
+  end
+
+  context 'compatibility with ::Socket' do
+
+    context '.new' do
+      it "creates basic sockets" do
+        socket = Celluloid::IO::Socket.new(Celluloid::IO::Socket::AF_INET, Celluloid::IO::Socket::SOCK_STREAM, 0)
+        expect(socket).to be_a ::Socket
+        socket.close
+      end
+    end
+
+    context '.pair' do
+      it "creates basic sockets" do
+        a,b = Celluloid::IO::Socket.pair( Celluloid::IO::Socket::AF_UNIX, Celluloid::IO::Socket::SOCK_DGRAM, 0)
+        expect(a).to be_a ::Socket
+        expect(b).to be_a ::Socket
+        a.close
+        b.close
+      end
+    end
+
+    context '.for_fd' do
+      it "creates basic sockets" do
+        socket = Celluloid::IO::Socket.new(Celluloid::IO::Socket::AF_INET, Celluloid::IO::Socket::SOCK_STREAM, 0)
+        copy = Celluloid::IO::Socket.for_fd(socket.fileno)
+        expect(copy).to be_a ::Socket
+        copy.close
+      end
+    end
+
+  end
+
+end

data/spec/celluloid/io/tcp_server_spec.rb

@@ -28,6 +28,33 @@ RSpec.describe Celluloid::IO::TCPServer, library: :IO do
         end
       end
 
+      it "sends information to the client later" do
+        class LaterActor
+          include Celluloid::IO
+          
+          def send_later(socket)
+            peer = socket.accept
+            after(0.4) { peer.write "1" }
+            after(0.4) { peer.write "2" }
+            peer
+          end
+        end
+        with_tcp_server(example_port) do |subject|
+          thread = Thread.new { TCPSocket.new(example_addr, example_port) }
+          actor = LaterActor.new
+          begin
+            peer = actor.send_later(subject)
+            client = thread.value
+            client.write payload
+            expect(peer.read(payload.size)).to eq payload # confirm the client read
+            Timeout::timeout(1) { expect(client.read(1)).to eq "1" }
+            Timeout::timeout(2) { expect(client.read(1)).to eq "2" }
+          ensure
+            actor.terminate if actor.alive?
+          end
+        end
+      end
+
       context "outside Celluloid::IO" do
         it "should be blocking" do
           with_tcp_server(example_port) do |subject|