celluloid-io 0.17.2 → 0.17.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: f22ca0d4783bd9c3d65491e35c23cb265f9f5921
-  data.tar.gz: 19eb07a8af91273aa9d02d0a13d8b8d7cc7fd42e
+  metadata.gz: 868ae36a7ec2c6a1f488023e9a2358af5e66cdfd
+  data.tar.gz: 90e7851f8bfbe6dc3c47b3d450bb674b2db407c5
 SHA512:
-  metadata.gz: 7461a398eda2e60590099d4794bb6bd7bc6d1854b1e69acfea49ef9ff898ba537d25025a89add4582aecb15b276b34bbdf0d84c2d4ba0100a3eefa23f3724476
-  data.tar.gz: 55426f5b1593876194494c4f193b824daddeaa3679493c84b36d5d8887e4c4f715aa710e4239fdb757065a0af0ebcf48585986af6d50cb06a1d612e5f76e5c7e
+  metadata.gz: 1346986683c4491cfbda904e9f399bd1e6c5c6f4b0ac416003f61b7b9c55b8f26c4f07237ed8088e68030acc60a2f117c2b1523d2a46fa44d050eb5a0fec5077
+  data.tar.gz: c5d8b43d6a89f49a5751c3c43dbee6bc0cb6b3c21a205350170163182ebda93542eca67076cdc725387358d0ae91a125bf162bb866df99547e9631082e723f0b

data/.travis.yml

@@ -3,6 +3,7 @@ language: ruby
 rvm:
   - rbx-2
   - jruby
+  - 2.3.0
   - 2.2.2
   - 2.2.0
   - 2.1.4

data/CHANGES.md

@@ -1,3 +1,35 @@
+0.17.3 (2016-01-18)
+-----
+* [#163](https://github.com/celluloid/celluloid-io/pull/163)
+  Support Ruby 2.3.0.
+
+* [#162](https://github.com/celluloid/celluloid-io/pull/162)
+  Fix broken specs.
+
+* [#160](https://github.com/celluloid/celluloid-io/pull/160)
+  Use a common super class for all socket wrappers.
+  ([@hannesg])
+
+* [#159](https://github.com/celluloid/celluloid-io/pull/159)
+  UNIXSocket: don't delegate #readline and #puts.
+  ([@hannesg])
+
+* [#158](https://github.com/celluloid/celluloid-io/pull/158)
+  Use unix sockets in unix spec instead of tcp sockets.
+  ([@hannesg])
+
+* [#157](https://github.com/celluloid/celluloid-io/pull/157)
+  Stream#close is not called in subclasses.
+  ([@hannesg])
+
+* [#155](https://github.com/celluloid/celluloid-io/pull/155)
+  Only close Selector it not already closed.
+
+* [#98](https://github.com/celluloid/celluloid-io/pull/98)
+  Added spec for writing later to a socket within a request/response cycle
+  using the timer primitives.
+  ([@TiagoCardoso1983])
+
 0.17.2 (2015-09-30)
 -----
 * Revamped test suite, using shared RSpec configuration layer provided by Celluloid itself.
@@ -84,3 +116,6 @@
 0.7.0
 -----
 * Initial release forked from Celluloid
+
+[@TiagoCardoso1983]: https://github.com/TiagoCardoso1983
+[@hannesg]: https://github.com/hannesg

data/lib/celluloid/io.rb

@@ -4,6 +4,7 @@ require "celluloid"
 require "celluloid/io/dns_resolver"
 require "celluloid/io/mailbox"
 require "celluloid/io/reactor"
+require "celluloid/io/socket"
 require "celluloid/io/stream"
 
 require "celluloid/io/tcp_server"

data/lib/celluloid/io/reactor.rb

@@ -49,7 +49,7 @@ module Celluloid
           # have woken up. However, in some cases, the monitor is already
           # invalid, e.g. in the case that we are terminating. We catch this
           # case explicitly.
-          monitor.close
+          monitor.close unless monitor.closed?
         end
       end
 

data/lib/celluloid/io/socket.rb

@@ -0,0 +1,80 @@
+module Celluloid
+  module IO
+    # Base class for all classes that wrap a ruby socket.
+    # @abstract
+    class Socket
+      extend Forwardable
+
+      def_delegators :@socket, :close, :close_read, :close_write, :closed?
+      def_delegators :@socket, :read_nonblock, :write_nonblock
+      def_delegators :@socket, :addr, :getsockopt, :setsockopt, :getsockname, :fcntl
+
+      # @param socket [BasicSocket, OpenSSL::SSL::SSLSocket]
+      def initialize(socket)
+        case socket
+        when ::BasicSocket, OpenSSL::SSL::SSLSocket
+          @socket = socket
+        else
+          raise ArgumentError, "expected a socket, got #{socket.inspect}"
+        end
+      end
+
+      # Returns the wrapped socket.
+      # @return [BasicSocket, OpenSSL::SSL::SSLSocket]
+      def to_io
+        @socket
+      end
+
+      # Compatibility
+      Constants = ::Socket::Constants
+      include Constants
+
+      # Celluloid::IO:Socket.new behaves like Socket.new for compatibility.
+      # This is is not problematic since Celluloid::IO::Socket is abstract.
+      # To instantiate a socket use one of its subclasses.
+      def self.new(*args)
+        if self == Celluloid::IO::Socket
+          return ::Socket.new(*args)
+        else
+          super
+        end
+      end
+
+      # Tries to convert the given ruby socket into a subclass of GenericSocket.
+      # @param socket
+      # @return [SSLSocket, TCPServer, TCPSocket, UDPSocket, UNIXServer, UNIXSocket]
+      # @return [nil] if the socket can't be converted
+      def self.try_convert(socket, convert_io = true)
+        case socket
+        when Celluloid::IO::Socket, Celluloid::IO::SSLServer
+          socket
+        when ::TCPServer
+          TCPServer.new(socket)
+        when ::TCPSocket
+          TCPSocket.new(socket)
+        when ::UDPSocket
+          UDPSocket.new(socket)
+        when ::UNIXServer
+          UNIXServer.new(socket)
+        when ::UNIXSocket
+          UNIXSocket.new(socket)
+        when OpenSSL::SSL::SSLServer
+          SSLServer.new(socket.to_io, socket.instance_variable_get(:@ctx))
+        when OpenSSL::SSL::SSLSocket
+          SSLSocket.new(socket)
+        else
+          if convert_io
+            return try_convert(IO.try_convert(socket), false)
+          end
+          nil
+        end
+      end
+
+      class << self
+        extend Forwardable
+        def_delegators '::Socket', *(::Socket.methods - self.methods - [:try_convert])
+      end
+
+    end
+  end
+end

data/lib/celluloid/io/ssl_server.rb

@@ -11,10 +11,7 @@ module Celluloid
       attr_reader :tcp_server
 
       def initialize(server, ctx)
-        if server.is_a?(::TCPServer)
-          server = Celluloid::IO::TCPServer.from_ruby_server(server)
-        end
-        @tcp_server = server
+        @tcp_server = Socket.try_convert(server)
         @ctx = ctx
         @start_immediately = true
       end

data/lib/celluloid/io/ssl_socket.rb

@@ -6,11 +6,7 @@ module Celluloid
     class SSLSocket < Stream
       extend Forwardable
 
-      def_delegators :@socket,
-                     :read_nonblock,
-                     :write_nonblock,
-                     :close,
-                     :closed?,
+      def_delegators :to_io,
                      :cert,
                      :cipher,
                      :client_ca,
@@ -22,14 +18,14 @@ module Celluloid
                      :sync_close=
 
       def initialize(io, ctx = OpenSSL::SSL::SSLContext.new)
-        super()
         @context = ctx
-        @socket = OpenSSL::SSL::SSLSocket.new(::IO.try_convert(io), @context)
-        @socket.sync_close = true if @socket.respond_to?(:sync_close=)
+        socket = OpenSSL::SSL::SSLSocket.new(::IO.try_convert(io), @context)
+        socket.sync_close = true if socket.respond_to?(:sync_close=)
+        super(socket)
       end
 
       def connect
-        @socket.connect_nonblock
+        to_io.connect_nonblock
         self
       rescue ::IO::WaitReadable
         wait_readable
@@ -37,7 +33,7 @@ module Celluloid
       end
 
       def accept
-        @socket.accept_nonblock
+        to_io.accept_nonblock
         self
       rescue ::IO::WaitReadable
         wait_readable
@@ -47,9 +43,6 @@ module Celluloid
         retry
       end
 
-      def to_io
-        @socket
-      end
     end
   end
 end

data/lib/celluloid/io/stream.rb

@@ -8,7 +8,7 @@
 module Celluloid
   module IO
     # Base class of all streams in Celluloid::IO
-    class Stream
+    class Stream < Socket
       include Enumerable
 
       # The "sync mode" of the stream
@@ -16,7 +16,8 @@ module Celluloid
       # See IO#sync for full details.
       attr_accessor :sync
 
-      def initialize
+      def initialize(socket)
+        super
         @eof  = false
         @sync = true
         @read_buffer = ''.force_encoding(Encoding::ASCII_8BIT)
@@ -309,7 +310,7 @@ module Celluloid
       # Closes the stream and flushes any unwritten data.
       def close
         flush rescue nil
-        sysclose
+        super
       end
 
       #######

data/lib/celluloid/io/tcp_server.rb

@@ -3,36 +3,51 @@ require 'socket'
 module Celluloid
   module IO
     # TCPServer with combined blocking and evented support
-    class TCPServer
+    class TCPServer < Socket
       extend Forwardable
-      def_delegators :@server, :listen, :sysaccept, :close, :closed?, :addr, :setsockopt
+      def_delegators :to_io, :listen, :sysaccept, :addr
 
-      def initialize(hostname_or_port, port = nil)
-        if port.nil?
-          @server = ::TCPServer.new(hostname_or_port)
+      # @overload initialize(port)
+      #   Opens a tcp server on the given port.
+      #   @param port [Numeric]
+      #
+      # @overload initialize(hostname, port)
+      #   Opens a tcp server on the given port and interface.
+      #   @param hostname [String]
+      #   @param port [Numeric]
+      #
+      # @overload initialize(socket)
+      #   Wraps an already existing tcp server instance.
+      #   @param socket [::TCPServer]
+      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 TCPServer)" unless socket.kind_of? ::TCPServer
+          super(socket)
         else
-          @server = ::TCPServer.new(hostname_or_port, port)
+          super(::TCPServer.new(*args))
         end
       end
 
+      # @return [TCPSocket]
       def accept
-        Celluloid::IO.wait_readable(@server)
+        Celluloid::IO.wait_readable(to_io)
         accept_nonblock
       end
 
+      # @return [TCPSocket]
       def accept_nonblock
-        Celluloid::IO::TCPSocket.new(@server.accept_nonblock)
-      end
-
-      def to_io
-        @server
+        Celluloid::IO::TCPSocket.new(to_io.accept_nonblock)
       end
 
       # Convert a Ruby TCPServer into a Celluloid::IO::TCPServer
+      # @deprecated Use .new instead.
       def self.from_ruby_server(ruby_server)
-        server = allocate
-        server.instance_variable_set(:@server, ruby_server)
-        server
+        warn "#from_ruby_server is deprecated please use .new instead"
+        
+        self.new(ruby_server)
       end
     end
   end

data/lib/celluloid/io/tcp_socket.rb

@@ -7,8 +7,7 @@ module Celluloid
     class TCPSocket < Stream
       extend Forwardable
 
-      def_delegators :@socket, :read_nonblock, :write_nonblock, :close, :close_read, :close_write, :closed?
-      def_delegators :@socket, :addr, :peeraddr, :setsockopt, :getsockname
+      def_delegators :to_io, :peeraddr
 
       # Open a TCP socket, yielding it to the given block and closing it
       # automatically when done (if a block is given)
@@ -25,91 +24,114 @@ module Celluloid
 
       # Convert a Ruby TCPSocket into a Celluloid::IO::TCPSocket
       # DEPRECATED: to be removed in a future release
+      # @deprecated Use {Celluloid::IO::TCPSocket#new} instead.
       def self.from_ruby_socket(ruby_socket)
         new(ruby_socket)
       end
 
-      # Opens a TCP connection to remote_host on remote_port. If local_host
-      # and local_port are specified, then those parameters are used on the
-      # local end to establish the connection.
-      def initialize(remote_host, remote_port = nil, local_host = nil, local_port = nil)
-        super()
-
-        # Allow users to pass in a Ruby TCPSocket directly
-        if remote_host.is_a? ::TCPSocket
-          @addr = nil
-          @socket = remote_host
-          return
-        elsif remote_port.nil?
-          fail ArgumentError, "wrong number of arguments (1 for 2)"
+      # @overload initialize(remote_host, remote_port = nil, local_host = nil, local_port = nil)
+      #   Opens a TCP connection to remote_host on remote_port. If local_host
+      #   and local_port are specified, then those parameters are used on the
+      #   local end to establish the connection.
+      #   @param remote_host [String, Resolv::IPv4, Resolv::IPv6]
+      #   @param remote_port [Numeric]
+      #   @param local_host  [String]
+      #   @param local_port  [Numeric]
+      #
+      # @overload initialize(socket)
+      #   Wraps an already existing tcp socket.
+      #   @param socket [::TCPSocket]
+      #
+      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 TCPSocket)" unless socket.kind_of? ::TCPSocket
+          super(socket)
+        else
+          super(create_socket(*args))
         end
+      end
+
+      # Receives a message
+      def recv(maxlen, flags = nil)
+        fail NotImplementedError, "flags not supported" if flags && !flags.zero?
+        readpartial(maxlen)
+      end
+
+      # Send a message
+      def send(msg, flags, dest_sockaddr = nil)
+        fail NotImplementedError, "dest_sockaddr not supported" if dest_sockaddr
+        fail NotImplementedError, "flags not supported" unless flags.zero?
+        write(msg)
+      end
+
+      # @return [Resolv::IPv4, Resolv::IPv6]
+      def addr
+        socket = to_io
+        ra = socket.remote_address
+        if ra.ipv4?
+          return Resolv::IPv4.create(ra.ip_address)
+        elsif ra.ipv6?
+          return Resolv::IPv6.create(ra.ip_address)
+        else
+          raise ArgumentError, "not an ip socket: #{socket.inspect}"
+        end
+      end
+    private
 
+      def create_socket(remote_host, remote_port = nil, local_host = nil, local_port = nil)
         # Is it an IPv4 address?
         begin
-          @addr = Resolv::IPv4.create(remote_host)
+          addr = Resolv::IPv4.create(remote_host)
         rescue ArgumentError
         end
 
         # Guess it's not IPv4! Is it IPv6?
-        unless @addr
+        unless addr
           begin
-            @addr = Resolv::IPv6.create(remote_host)
+            addr = Resolv::IPv6.create(remote_host)
           rescue ArgumentError
           end
         end
 
         # Guess it's not an IP address, so let's try DNS
-        unless @addr
+        unless addr
           addrs = Array(DNSResolver.new.resolve(remote_host))
           fail Resolv::ResolvError, "DNS result has no information for #{remote_host}" if addrs.empty?
 
           # Pseudorandom round-robin DNS support :/
-          @addr = addrs[rand(addrs.size)]
+          addr = addrs[rand(addrs.size)]
         end
 
-        case @addr
+        case addr
         when Resolv::IPv4
           family = Socket::AF_INET
         when Resolv::IPv6
           family = Socket::AF_INET6
-        else fail ArgumentError, "unsupported address class: #{@addr.class}"
+        else fail ArgumentError, "unsupported address class: #{addr.class}"
         end
 
-        @socket = Socket.new(family, Socket::SOCK_STREAM, 0)
-        @socket.bind Addrinfo.tcp(local_host, local_port) if local_host
+        socket = Socket.new(family, Socket::SOCK_STREAM, 0)
+        socket.bind Addrinfo.tcp(local_host, local_port) if local_host
 
         begin
-          @socket.connect_nonblock Socket.sockaddr_in(remote_port, @addr.to_s)
+          socket.connect_nonblock Socket.sockaddr_in(remote_port, addr.to_s)
         rescue Errno::EINPROGRESS, Errno::EALREADY
           # JRuby raises EINPROGRESS, MRI raises EALREADY
-
-          wait_writable
+          Celluloid::IO.wait_writable(socket)
 
           # HAX: for some reason we need to finish_connect ourselves on JRuby
           # This logic is unnecessary but JRuby still throws Errno::EINPROGRESS
           # if we retry the non-blocking connect instead of just finishing it
-          retry unless RUBY_PLATFORM == "java" && @socket.to_channel.finish_connect
+          retry unless RUBY_PLATFORM == "java" && socket.to_channel.finish_connect
         rescue Errno::EISCONN
           # We're now connected! Yay exceptions for flow control
           # NOTE: This is the approach the Ruby stdlib docs suggest ;_;
         end
-      end
-
-      def to_io
-        @socket
-      end
-
-      # Receives a message
-      def recv(maxlen, flags = nil)
-        fail NotImplementedError, "flags not supported" if flags && !flags.zero?
-        readpartial(maxlen)
-      end
 
-      # Send a message
-      def send(msg, flags, dest_sockaddr = nil)
-        fail NotImplementedError, "dest_sockaddr not supported" if dest_sockaddr
-        fail NotImplementedError, "flags not supported" unless flags.zero?
-        write(msg)
+        return socket
       end
     end
   end