socketry 0.5.0 → 0.6.0

data/CHANGES.md

@@ -1,31 +0,0 @@
-## 0.5.0 (2016-11-26)
-
-* Require Ruby 2.2.6+ (earlier 2.2 versions had async I/O bugs)
-* Extract Socketry::SSL::Socket#accept into its own method
-* Simplify Socketry::SSL::Socket#from_socket API
-* Raise Socketry::SSL::CertificateVerifyError for certificate verification errors
-* Specs and bugfixes for Socketry::SSL::Server
-* Rename Socketry::UDP::Datagram accessors to `remote_host`, `remote_addr`, and `remote_port`
-* Update to RuboCop 0.45.0
-
-## 0.4.0 (2016-11-25)
-
-* Specs and bugfixes for SSL sockets
-* Specs and bugfixes for UDP sockets
-* Add Socketry::UDP::Datagram class
-* Add Socketry::AddressInUseError exception
-
-## 0.3.0 (2016-09-24)
-
-* Implement Socketry::TCP::Socket#read and #write
-* Use StandardError as the base class for Socketry::Error
-* Add Socketry::ConnectionRefusedError
-* Parameterize SSL contexts
-
-## 0.2.0 (2016-09-12)
-
-* Rename Socketry::TCP::Socket#connected? -> #closed?
-
-## 0.1.0 (2016-09-11)
-
-* Initial release

data/Gemfile

@@ -1,20 +0,0 @@
-# frozen_string_literal: true
-
-source "https://rubygems.org"
-
-gemspec
-
-group :development do
-  gem "guard-rspec", require: false
-  gem "pry", require: false
-end
-
-group :test do
-  gem "rspec", "~> 3", require: false
-  gem "rubocop", "0.45.0", require: false
-  gem "coveralls", require: false
-end
-
-group :development, :test do
-  gem "rake"
-end

data/Guardfile

@@ -1,10 +0,0 @@
-# frozen_string_literal: true
-
-directories %w(lib spec)
-clearing :on
-
-guard :rspec, cmd: "bundle exec rspec" do
-  watch(%r{^spec/.+_spec\.rb$})
-  watch(%r{^lib/(.+)\.rb$})    { |m| "spec/#{m[1]}_spec.rb" }
-  watch("spec/spec_helper.rb") { "spec" }
-end

data/LICENSE.txt

@@ -1,22 +0,0 @@
-MIT License
-
-Copyright (c) 2016 Tony Arcieri
-
-Permission is hereby granted, free of charge, to any person obtaining
-a copy of this software and associated documentation files (the
-"Software"), to deal in the Software without restriction, including
-without limitation the rights to use, copy, modify, merge, publish,
-distribute, sublicense, and/or sell copies of the Software, and to
-permit persons to whom the Software is furnished to do so, subject to
-the following conditions:
-
-The above copyright notice and this permission notice shall be
-included in all copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
-EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
-MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
-NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
-LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
-OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
-WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -1,108 +0,0 @@
-# Socketry [![Gem Version][gem-image]][gem-link] [![Build Status][build-image]][build-link] [![Code Climate][codeclimate-image]][codeclimate-link] [![Coverage Status][coverage-image]][coverage-link] [![MIT licensed][license-image]][license-link]
-
-[gem-image]: https://badge.fury.io/rb/socketry.svg
-[gem-link]: https://rubygems.org/gems/socketry
-[build-image]: https://secure.travis-ci.org/socketry/socketry.svg?branch=master
-[build-link]: https://travis-ci.org/socketry/socketry
-[codeclimate-image]: https://codeclimate.com/github/socketry/socketry.svg?branch=master
-[codeclimate-link]: https://codeclimate.com/github/socketry/socketry
-[coverage-image]: https://coveralls.io/repos/github/socketry/socketry/badge.svg?branch=master
-[coverage-link]: https://coveralls.io/github/socketry/socketry?branch=master
-[license-image]: https://img.shields.io/badge/license-MIT-blue.svg
-[license-link]: https://github.com/socketry/socketry/blob/master/LICENSE.txt
-
-High-level Ruby socket library with support for TCP, UDP, and SSL sockets.
-
-Implements thread-safe timeouts using asynchronous I/O and high-precision monotonic timers.
-
-## Motivation
-
-By default, Ruby sockets do not provide a built-in timeout mechanism. The only
-timeout mechanism provided by the language leverages [timeout.rb], which uses
-[unsafe multithreaded behaviors] to implement timeouts.
-
-While Socketry provides a synchronous, blocking API similar to Ruby's own
-`TCPSocket` and `UDPSocket` classes, behind the scenes it uses non-blocking I/O
-to implement thread-safe timeouts.
-
-[timeout.rb]: http://ruby-doc.org/stdlib-2.3.1/libdoc/timeout/rdoc/Timeout.html
-[unsafe multithreaded behaviors]: http://blog.headius.com/2008/02/ruby-threadraise-threadkill-timeoutrb.html
-
-## Installation
-
-Add this line to your application's Gemfile:
-
-```ruby
-gem "socketry"
-```
-
-And then execute:
-
-    $ bundle
-
-Or install it yourself as:
-
-    $ gem install socketry
-
-## Basic Usage
-
-Below is a basic example of how to use Socketry to make an HTTPS request:
-
-```ruby
-require "socketry"
-
-socket = Socketry::SSL::Socket.connect("github.com", 443)
-socket.writepartial("GET / HTTP/1.0\r\nHost: github.com\r\n\r\n")
-p socket.readpartial(1024)
-```
-
-[TCP], [SSL], and [UDP] servers and sockets also available.
-
-[TCP]: https://github.com/socketry/socketry/wiki/TCP
-[SSL]: https://github.com/socketry/socketry/wiki/SSL
-[UDP]: https://github.com/socketry/socketry/wiki/UDP
-
-## Documentation
-
-[Please see the Socketry wiki](https://github.com/socketry/socketry/wiki)
-for more detailed documentation and usage notes.
-
-[YARD API documentation](http://www.rubydoc.info/gems/socketry/)
-is also available.
-
-## Supported Ruby Versions
-
-This library aims to support and is [tested against][travis] the following Ruby
-versions:
-
-* Ruby 2.2.6+
-* Ruby 2.3.x
-* JRuby 9.1.6.0+
-
-If something doesn't work on one of these versions, it's a bug.
-
-This library may inadvertently work (or seem to work) on other Ruby versions,
-however support will only be provided for the versions listed above.
-
-If you would like this library to support another Ruby version or
-implementation, you may volunteer to be a maintainer. Being a maintainer
-entails making sure all tests run and pass on that implementation. When
-something breaks on your implementation, you will be responsible for providing
-patches in a timely fashion. If critical issues for a particular implementation
-exist at the time of a major release, support for that Ruby version may be
-dropped.
-
-[travis]: http://travis-ci.org/socketry/socketry
-
-## Contributing
-
-* Fork this repository on github
-* Make your changes and send us a pull request
-* If we like them we'll merge them
-* If we've accepted a patch, feel free to ask for commit access
-
-## License
-
-Copyright (c) 2016 Tony Arcieri. Distributed under the MIT License. See
-[LICENSE.txt](https://github.com/socketry/socketry/blob/master/LICENSE.txt)
-for further details.

data/Rakefile

@@ -1,10 +0,0 @@
-# frozen_string_literal: true
-require "bundler/gem_tasks"
-
-require "rspec/core/rake_task"
-RSpec::Core::RakeTask.new
-
-require "rubocop/rake_task"
-RuboCop::RakeTask.new
-
-task default: %w(spec rubocop)

data/lib/socketry/exceptions.rb

@@ -1,40 +0,0 @@
-# frozen_string_literal: true
-
-module Socketry
-  # Generic catch all for all Socketry errors
-  Error = Class.new(StandardError)
-
-  # Failed to connect to a remote host
-  ConnectionRefusedError = Class.new(Socketry::Error)
-
-  # Invalid address
-  AddressError = Class.new(Socketry::Error)
-
-  # Address is already in use
-  AddressInUseError = Class.new(Socketry::Error)
-
-  # Timeouts performing an I/O operation
-  TimeoutError = Class.new(Socketry::Error)
-
-  # Cannot perform operation in current state
-  StateError = Class.new(Socketry::Error)
-
-  # Internal consistency error within the library
-  InternalError = Class.new(Socketry::Error)
-
-  module Resolver
-    # DNS resolution errors
-    Error = Class.new(Socketry::AddressError)
-  end
-
-  module SSL
-    # Errors related to SSL
-    Error = Class.new(Socketry::Error)
-
-    # Certificate could not be verified
-    CertificateVerifyError = Class.new(Socketry::SSL::Error)
-
-    # Hostname verification error
-    HostnameError = Class.new(CertificateVerifyError)
-  end
-end

data/lib/socketry/resolver/resolv.rb

@@ -1,67 +0,0 @@
-# frozen_string_literal: true
-
-require "resolv"
-
-module Socketry
-  module Resolver
-    # Pure Ruby DNS resolver provided by the standard library
-    class Resolv
-      # Resolve a hostname by creating and discaring a Socketry::Resolver::Resolv
-      # instance. For better performance, create and reuse an instance.
-      def self.resolve(hostname, **options)
-        resolver = new
-        begin
-          resolver.resolve(hostname, **options)
-        ensure
-          resolver.close
-        end
-      end
-
-      # Create a new instance of Socketry::Resolver::Resolv.
-      #
-      # Arguments are passed directly to Resolv::DNS. See the Ruby documentation
-      # for more information:
-      #
-      # https://ruby-doc.org/stdlib-2.3.1/libdoc/resolv/rdoc/Resolv/DNS.html
-      #
-      def initialize(*args)
-        @hosts = ::Resolv::Hosts.new
-        @resolver = ::Resolv::DNS.new(*args)
-      end
-
-      # Resolve a domain name using IPSocket.getaddress. This uses getaddrinfo(3)
-      # on POSIX operating systems.
-      #
-      # @param hostname [String] name of the host whose IP address we'd like to obtain
-      # @return [IPAddr] resolved IP address
-      # @raise [Socketry::Resolver::Error] an error occurred resolving the domain name
-      # @raise [Socketry::TimeoutError] a timeout occured before the name could be resolved
-      # @raise [Socketry::AddressError] the name was resolved to an unsupported address
-      def resolve(hostname, timeout: nil)
-        raise TypeError, "expected String, got #{hostname.class}" unless hostname.is_a?(String)
-        return IPAddr.new(@hosts.getaddress(hostname).sub(/%.*$/, ""))
-      rescue ::Resolv::ResolvError
-        case timeout
-        when Integer, Float
-          @resolver.timeouts = timeout
-        when NilClass
-          nil # no timeout
-        else raise TypeError, "expected Numeric, got #{timeout.class}"
-        end
-
-        begin
-          IPAddr.new(@resolver.getaddress(hostname).to_s)
-        rescue ::Resolv::ResolvError => ex
-          raise Socketry::Resolver::Error, ex.message, ex.backtrace
-        rescue ::Resolv::ResolvTimeout => ex
-          raise Socketry::TimeoutError, ex.message, ex.backtrace
-        end
-      end
-
-      # Close the resolver
-      def close
-        @resolver.close
-      end
-    end
-  end
-end

data/lib/socketry/resolver/system.rb

@@ -1,48 +0,0 @@
-# frozen_string_literal: true
-
-require "timeout"
-
-module Socketry
-  module Resolver
-    # System DNS resolver backed by the POSIX getaddrinfo(3) function
-    module System
-      module_function
-
-      # Resolve a domain name using IPSocket.getaddress. This uses getaddrinfo(3)
-      # on POSIX operating systems.
-      #
-      # @param hostname [String] name of the host whose IP address we'd like to obtain
-      # @return [IPAddr] resolved IP address
-      # @raise [Socketry::Resolver::Error] an error occurred resolving the domain name
-      # @raise [Socketry::TimeoutError] a timeout occured before the name could be resolved
-      # @raise [Socketry::AddressError] the name was resolved to an unsupported address
-      def resolve(hostname, timeout: nil)
-        raise TypeError, "expected String, got #{hostname.class}" unless hostname.is_a?(String)
-
-        begin
-          case timeout
-          when Integer, Float
-            # NOTE: ::Timeout is not thread safe. For thread safety, use Socketry::Resolver::Resolv
-            result = ::Timeout.timeout(timeout) { IPSocket.getaddress(hostname) }
-          when NilClass
-            result = IPSocket.getaddress(hostname)
-          else raise TypeError, "expected Numeric, got #{timeout.class}"
-          end
-        rescue ::SocketError => ex
-          raise Socketry::Resolver::Error, ex.message, ex.backtrace
-        rescue ::Timeout::Error => ex
-          raise Socketry::TimeoutError, ex.message, ex.backtrace
-        end
-
-        begin
-          IPAddr.new(result)
-        rescue IPAddr::InvalidAddressError => ex
-          raise Socketry::AddressError, ex.message, ex.backtrace
-        end
-      end
-    end
-
-    # Use Socketry::Resolver::System as the default resolver
-    DEFAULT_RESOLVER = System
-  end
-end

data/lib/socketry/ssl/server.rb

@@ -1,53 +0,0 @@
-# frozen_string_literal: true
-
-module Socketry
-  # Secure Sockets Layer (a.k.a. Transport Layer Security, or TLS)
-  module SSL
-    # SSL Server
-    class Server < Socketry::TCP::Server
-      # Create a new SSL server
-      #
-      # @return [Socketry::SSL::Server]
-      def initialize(
-        hostname_or_port,
-        port = nil,
-        ssl_socket_class: OpenSSL::SSL::SSLSocket,
-        ssl_params: nil,
-        **args
-      )
-        raise TypeError, "expected Hash, got #{ssl_params.class}" if ssl_params && !ssl_params.is_a?(Hash)
-
-        @ssl_socket_class = ssl_socket_class
-        @ssl_params = ssl_params
-
-        super(hostname_or_port, port, **args)
-      end
-
-      # Accept a connection to the server
-      #
-      # Note that this method also performs an SSL handshake and will therefore
-      # block other sockets which are ready to be accepted.
-      #
-      # Multithreaded servers should invoke this method after spawning a thread
-      # to ensure a slow/malicious connection can't cause a denial-of-service
-      # attack against the server.
-      #
-      # @param timeout [Numeric, NilClass] (default nil, unlimited) seconds to wait before aborting the accept
-      #
-      # @return [Socketry::SSL::Socket]
-      def accept(timeout: nil, **args)
-        tcp_socket = super(timeout: timeout, **args)
-
-        ssl_socket = Socketry::SSL::Socket.new(
-          read_timeout:     @read_timeout,
-          write_timeout:    @write_timeout,
-          resolver:         @resolver,
-          ssl_socket_class: @ssl_socket_class,
-          ssl_params:       @ssl_params
-        )
-
-        ssl_socket.accept(tcp_socket, timeout: timeout)
-      end
-    end
-  end
-end

data/lib/socketry/ssl/socket.rb

@@ -1,188 +0,0 @@
-# frozen_string_literal: true
-
-module Socketry
-  # Secure Sockets Layer (a.k.a. Transport Layer Security, or TLS)
-  module SSL
-    # SSL Sockets
-    class Socket < Socketry::TCP::Socket
-      # Create an unconnected Socketry::SSL::Socket
-      #
-      # @param read_timeout [Numeric] Seconds to wait before an uncompleted read errors
-      # @param write_timeout [Numeric] Seconds to wait before an uncompleted write errors
-      # @param timer [Object] A timekeeping object to use for measuring timeouts
-      # @param resolver [Object] A resolver object to use for resolving DNS names
-      # @param socket_class [Object] Underlying socket class which implements I/O ops
-      # @param ssl_socket_class [Object] Class which provides the underlying SSL implementation
-      # @param ssl_context [OpenSSL::SSL::SSLContext] SSL configuration object
-      # @param ssL_params [Hash] Parameter hash to set on the given SSL context
-      #
-      # @return [Socketry::SSL::Socket]
-      def initialize(
-        ssl_socket_class: OpenSSL::SSL::SSLSocket,
-        ssl_context: OpenSSL::SSL::SSLContext.new,
-        ssl_params: nil,
-        **args
-      )
-        raise TypeError, "invalid SSL context (#{ssl_context.class})" unless ssl_context.is_a?(OpenSSL::SSL::SSLContext)
-        raise TypeError, "expected Hash, got #{ssl_params.class}" if ssl_params && !ssl_params.is_a?(Hash)
-
-        @ssl_socket_class = ssl_socket_class
-
-        @ssl_context = ssl_context
-        @ssl_context.set_params(ssl_params) if ssl_params && !ssl_params.empty?
-
-        @ssl_socket = nil
-
-        super(**args)
-      end
-
-      # Make an SSL connection to a remote host
-      #
-      # @param remote_addr [String] DNS name or IP address of the host to connect to
-      # @param remote_port [Fixnum] TCP port to connect to
-      # @param local_addr [String] DNS name or IP address to bind to locally
-      # @param local_port [Fixnum] Local TCP port to bind to
-      # @param timeout [Numeric] Number of seconds to wait before aborting connect
-      # @param enable_sni [true, false] (default: true) Enables Server Name Indication (SNI)
-      # @param verify_hostname [true, false] (default: true) Ensure server's hostname matches cert
-      #
-      # @raise [Socketry::AddressError] an invalid address was given
-      # @raise [Socketry::TimeoutError] connect operation timed out
-      # @raise [Socketry::SSL::Error] an error occurred negotiating an SSL connection
-      # @return [self]
-      def connect(
-        remote_addr,
-        remote_port,
-        local_addr: nil,
-        local_port: nil,
-        timeout: Socketry::Timeout::DEFAULT_TIMEOUTS[:connect],
-        enable_sni: true,
-        verify_hostname: true
-      )
-        super(remote_addr, remote_port, local_addr: local_addr, local_port: local_port, timeout: timeout)
-
-        @ssl_socket = @ssl_socket_class.new(@socket, @ssl_context)
-        @ssl_socket.hostname = remote_addr if enable_sni
-        @ssl_socket.sync_close = true
-
-        begin
-          @ssl_socket.connect_nonblock
-        rescue IO::WaitReadable
-          retry if @socket.wait_readable(timeout)
-          raise Socketry::TimeoutError, "connection to #{remote_addr}:#{remote_port} timed out"
-        rescue IO::WaitWritable
-          retry if @socket.wait_writable(timeout)
-          raise Socketry::TimeoutError, "connection to #{remote_addr}:#{remote_port} timed out"
-        rescue OpenSSL::SSL::SSLError => ex
-          raise Socketry::SSL::CertificateVerifyError, ex.message if ex.message.include?("certificate verify failed")
-          raise Socketry::SSL::Error, ex.message, ex.backtrace
-        end
-
-        begin
-          @ssl_socket.post_connection_check(remote_addr) if verify_hostname
-        rescue OpenSSL::SSL::SSLError => ex
-          raise Socketry::SSL::HostnameError, ex.message, ex.backtrace
-        end
-
-        self
-      rescue => ex
-        @socket.close rescue nil
-        @socket = nil
-        @ssl_socket.close rescue nil
-        @ssl_socket = nil
-        raise ex
-      end
-
-      # Accept an SSL connection from a Socketry or Ruby socket
-      #
-      # @param tcp_socket [TCPSocket, Socketry::TCP::Socket] raw TCP socket to begin SSL handshake with
-      # @param timeout [Numeric, NilClass] (default nil, unlimited) seconds to wait before aborting the accept
-      #
-      # @return [self]
-      def accept(tcp_socket, timeout: nil)
-        tcp_socket = IO.try_convert(tcp_socket) || raise(TypeError, "couldn't convert #{tcp_socket.class} to IO")
-        ssl_socket = @ssl_socket_class.new(tcp_socket, @ssl_context)
-
-        begin
-          ssl_socket.accept_nonblock
-        rescue IO::WaitReadable
-          retry if IO.select([tcp_socket], nil, nil, timeout)
-          raise Socketry::TimeoutError, "failed to complete handshake after #{timeout} seconds"
-        rescue IO::WaitWritable
-          retry if IO.select(nil, [tcp_socket], nil, timeout)
-          raise Socketry::TimeoutError, "failed to complete handshake after #{timeout} seconds"
-        end
-
-        from_socket(ssl_socket)
-      end
-
-      # Wrap a Ruby OpenSSL::SSL::SSLSocket (or other low-level SSL socket)
-      #
-      # @param ssl_socket [OpenSSL::SSL::SSLSocket] SSL socket class associated with this socket
-      #
-      # @return [self]
-      def from_socket(ssl_socket)
-        raise TypeError, "expected #{@ssl_socket_class}, got #{ssl_socket.class}" unless ssl_socket.is_a?(@ssl_socket_class)
-        raise StateError, "already connected" if @socket
-
-        @socket = ssl_socket.to_io
-        @ssl_socket = ssl_socket
-        @ssl_socket.sync_close = true
-
-        self
-      end
-
-      # Perform a non-blocking read operation
-      #
-      # @param size [Fixnum] number of bytes to attempt to read
-      # @param outbuf [String, NilClass] an optional buffer into which data should be read
-      #
-      # @raise [Socketry::Error] an I/O operation failed
-      # @return [String, :wait_readable] data read, or :wait_readable if operation would block
-      def read_nonblock(size, outbuf: nil)
-        case outbuf
-        when String
-          perform { @ssl_socket.read_nonblock(size, outbuf, exception: false) }
-        when NilClass
-          perform { @ssl_socket.read_nonblock(size, exception: false) }
-        else raise TypeError, "unexpected outbuf class: #{outbuf.class}"
-        end
-      end
-
-      # Perform a non-blocking write operation
-      #
-      # @param data [String] number of bytes to attempt to read
-      #
-      # @raise [Socketry::Error] an I/O operation failed
-      # @return [Fixnum, :wait_writable] number of bytes written, or :wait_writable if op would block
-      def write_nonblock(data)
-        perform { @ssl_socket.write_nonblock(data, exception: false) }
-      end
-
-      # Close the socket
-      #
-      # @return [true, false] true if the socket was open, false if closed
-      def close
-        @ssl_socket.close rescue nil
-        super
-      end
-
-      private
-
-      # Perform a non-blocking I/O operation
-      def perform
-        ensure_connected
-        yield
-      # Some buggy Rubies continue to raise this exception
-      rescue IO::WaitWritable
-        :wait_writable
-      # Due to SSL, we may need to write to complete a read (e.g. handshaking, renegotiation)
-      rescue IO::WaitReadable
-        :wait_readable
-      rescue => ex
-        # TODO: more specific exceptions
-        raise Socketry::Error, ex.message, ex.backtrace
-      end
-    end
-  end
-end

data/lib/socketry/tcp/server.rb

@@ -1,85 +0,0 @@
-# frozen_string_literal: true
-
-module Socketry
-  # Transmission Control Protocol
-  module TCP
-    # Transmission Control Protocol servers: Accept connections from the network
-    class Server
-      include Socketry::Timeout
-      alias uptime lifetime
-
-      attr_reader :read_timeout, :write_timeout, :resolver, :socket_class
-
-      # Create a new TCP server, yielding the server socket and auto-closing it
-      def self.open(hostname_or_port, port = nil, **args)
-        server = new(hostname_or_port, port, **args)
-        result = yield server
-        server.close
-        result
-      end
-
-      # Create a new TCP server
-      #
-      # @return [Socketry::TCP::Server]
-      def initialize(
-        hostname_or_port,
-        port = nil,
-        read_timeout: Socketry::Timeout::DEFAULT_TIMEOUTS[:read],
-        write_timeout: Socketry::Timeout::DEFAULT_TIMEOUTS[:write],
-        timer: Socketry::Timeout::DEFAULT_TIMER.new,
-        resolver: Socketry::Resolver::DEFAULT_RESOLVER,
-        server_class: ::TCPServer,
-        socket_class: ::TCPSocket
-      )
-        @read_timeout  = read_timeout
-        @write_timeout = write_timeout
-        @resolver      = resolver
-        @socket_class  = socket_class
-
-        if port
-          @server = server_class.new(@resolver.resolve(hostname_or_port).to_s, port)
-        else
-          @server = server_class.new(hostname_or_port)
-        end
-
-        start_timer(timer)
-      rescue Errno::EADDRINUSE => ex
-        raise AddressInUseError, ex.message, ex.backtrace
-      end
-
-      # Accept a connection to the server
-      #
-      # @param timeout [Numeric, NilClass] seconds to wait before aborting the accept
-      # @return [Socketry::TCP::Socket]
-      def accept(timeout: nil)
-        set_timeout(timeout)
-
-        begin
-          # Note: `exception: false` for TCPServer#accept_nonblock is only supported in Ruby 2.3+
-          ruby_socket = @server.accept_nonblock
-        rescue IO::WaitReadable, Errno::EAGAIN
-          # Ruby 2.2 has trouble using io/wait here
-          retry if IO.select([@server], nil, nil, time_remaining(timeout))
-          raise Socketry::TimeoutError, "no connection received after #{timeout} seconds"
-        end
-
-        Socketry::TCP::Socket.new(
-          read_timeout:  @read_timeout,
-          write_timeout: @write_timeout,
-          resolver:      @resolver,
-          socket_class:  @socket_class
-        ).from_socket(ruby_socket)
-      ensure
-        clear_timeout(timeout)
-      end
-
-      # Close the server
-      def close
-        return false unless @server
-        @server.close rescue nil
-        @server = nil
-        true
-      end
-    end
-  end
-end