arborist 0.2.0.pre20170519125456 → 0.2.0

data/lib/arborist/mixins.rb

@@ -86,6 +86,17 @@ module Arborist
 			attr_predicate( attrname )
 		end
 
+
+		### Create an method that is both a reader and a writer for an instance
+		### variable. If called with a (non-nil) argument, it will set the variable to
+		### the new value. It returns whatever the instance variable is set to.
+		def dsl_accessor( attrname )
+			define_method( attrname ) do |arg=nil|
+				instance_variable_set( "@#{attrname}", arg ) unless arg.nil?
+				return instance_variable_get( "@#{attrname}" )
+			end
+		end
+
 	end # module MethodUtilities
 
 

data/lib/arborist/monitor.rb

@@ -10,8 +10,9 @@ using Arborist::TimeRefinements
 
 # A declaration of an action to run against Manager nodes to update their state.
 class Arborist::Monitor
-	extend Loggability,
-	       Arborist::MethodUtilities
+	extend Configurability,
+		   Loggability,
+		   Arborist::MethodUtilities
 
 	# Loggability API -- write logs to the Arborist log host
 	log_to :arborist
@@ -30,9 +31,16 @@ class Arborist::Monitor
 	# The default monitoring interval, in seconds
 	DEFAULT_INTERVAL = 5.minutes
 
-	##
-	# The default number of seconds to defer startup to splay common intervals
-	DEFAULT_SPLAY = 0
+
+	# Configurability API -- use the 'arborist' section
+	configurability( 'arborist.monitor' ) do
+
+		##
+		# A default splay to apply to all Monitors.
+		setting :splay, default: 0 do |value|
+			Float( value )
+		end
+	end
 
 
 	Arborist.add_dsl_constructor( self ) do |description=nil, key=nil, &block|
@@ -58,7 +66,8 @@ class Arborist::Monitor
 			nodes.each do |(identifier, data)|
 				self.log.debug "Serializing node properties for %s" % [ identifier ]
 				prop_map = data.collect do |key, val|
-					"%s=%s" % [key, Shellwords.escape(val)]
+					val = val.join( ',' ) if val.is_a?( Array )
+					"%s=%s" % [ key, Shellwords.escape(val) ]
 				end
 
 				self.log.debug "  writing %d properties to %p" % [ prop_map.size, io ]
@@ -145,13 +154,13 @@ class Arborist::Monitor
 	### returned.
 	def initialize( description=nil, key=nil, &block )
 		@key = key
-		@description = description
+		@description = description || self.class.name
 		@interval = DEFAULT_INTERVAL
-		@splay = DEFAULT_SPLAY
+		@splay = Arborist::Monitor.splay
 
 		@positive_criteria = {}
 		@negative_criteria = {}
-		@include_down = false
+		@exclude_down = false
 		@node_properties = []
 
 		@exec_command = nil
@@ -198,7 +207,7 @@ class Arborist::Monitor
 	##
 	# Flag for whether the monitor will include downed hosts in its search. Defaults
 	# to +false+.
-	attr_predicate :include_down
+	attr_predicate :exclude_down
 
 	##
 	# The list of node properties to include when running the monitor.
@@ -224,7 +233,7 @@ class Arborist::Monitor
 
 	### Return a string representation of the object suitable for debugging.
 	def inspect
-		return "#<%p:%#x %s (every %ds ±%ds)>" % [
+		return "#<%p:%#x %s (every %ds +-%ds)>" % [
 			self.class,
 			self.object_id * 2,
 			self.description || "(no description)",
@@ -330,7 +339,7 @@ class Arborist::Monitor
 	### for nodes it will run against.
 	def match( criteria )
 		self.positive_criteria.merge!( criteria )
-		@include_down = !self.include_down &&
+		@exclude_down = self.exclude_down &&
 			Arborist::Node::UNREACHABLE_STATES.include?( self.positive_criteria[:status] )
 	end
 
@@ -344,9 +353,9 @@ class Arborist::Monitor
 
 	### Specify that the monitor should (or should not) include nodes which have been
 	### marked 'down'.
-	def include_down( flag=nil )
-		@include_down = flag unless flag.nil?
-		return @include_down
+	def exclude_down( flag=nil )
+		@exclude_down = flag unless flag.nil?
+		return @exclude_down
 	end
 
 
@@ -363,9 +372,11 @@ class Arborist::Monitor
 			self.log.warn "Ignored block with exec %s (%p)" % [ command.first, block ] if block
 
 			if command.first.respond_to?( :run )
-				@exec_block = command.first.method( :run )
+				runner = command.first
+				@exec_block = runner.method( :run )
+				@node_properties |= runner.node_properties if runner.respond_to?( :node_properties )
 			else
-				@exec_command = command
+				@exec_command = command.map( &:to_s )
 			end
 
 			return
@@ -408,6 +419,7 @@ class Arborist::Monitor
 	### external command.
 	def exec_callbacks( mod )
 		self.log.info "Setting exec callbacks handler to: %p" % [ mod.name ]
+		@node_properties |= mod.node_properties if mod.respond_to?( :node_properties )
 		self.exec_callbacks_mod = mod
 	end
 

data/lib/arborist/monitor/connection_batching.rb

@@ -0,0 +1,293 @@
+# -*- ruby -*-
+# frozen_string_literal: true
+
+require 'loggability'
+
+require 'arborist/monitor' unless defined?( Arborist::Monitor )
+require 'arborist/mixins'
+
+using Arborist::TimeRefinements
+
+
+# A mixin for adding batched connections for socket-based monitors.
+module Arborist::Monitor::ConnectionBatching
+
+	# The default number of connections to have open -- this should be well under
+	# the RLIMIT_NOFILE of the current process.
+	DEFAULT_BATCH_SIZE = 150
+
+	# The default connection timeout
+	DEFAULT_TIMEOUT = 2.0
+
+
+	# An object that manages batching of connections and gathering results.
+	class BatchRunner
+		extend Loggability
+
+		# Loggability API -- log to the Arborist logger
+		log_to :arborist
+
+
+		### Create a new BatchRunner for the specified +enum+ (an Enumerator)
+		def initialize( enum, batch_size, timeout )
+			@enum              = enum
+			@results           = {}
+			@current_batch     = []
+			@connection_hashes = {}
+			@start             = nil
+			@batch_size        = batch_size || DEFAULT_BATCH_SIZE
+			@timeout           = timeout || DEFAULT_TIMEOUT
+		end
+
+
+		######
+		public
+		######
+
+		##
+		# The Enumerator that yields connection hashes
+		attr_accessor :enum
+
+		##
+		# The results hash
+		attr_reader :results
+
+		##
+		# The batch of connection hashes that are currently being selected, ordered from
+		# oldest to newest.
+		attr_reader :current_batch
+
+		##
+		# An index of the current batch's connection hashes by connection.
+		attr_reader :connection_hashes
+
+		##
+		# The Time the batch runner started.
+		attr_accessor :start
+
+		##
+		# The maximum number of connections to have running at any time.
+		attr_reader :batch_size
+
+		##
+		# The connection timeout from the monitor, in seconds
+		attr_reader :timeout
+
+
+		### Returns +true+ if the runner has been run and all connections have been
+		### handled.
+		def finished?
+			return self.start && self.enum.nil? && self.current_batch.empty?
+		end
+
+
+		### Returns +true+ if the current batch is at capacity.
+		def batch_full?
+			return self.current_batch.length >= self.batch_size
+		end
+
+
+		### Fetch the next connection from the Enumerator, unsetting the enumerator and
+		### returning +nil+ when it reaches the end.
+		def next_connection
+			conn_hash = self.enum.next
+			conn_hash[:start] = Time.now
+			conn_hash[:timeout_at] = conn_hash[:start] + self.timeout
+
+			return conn_hash
+		rescue StopIteration
+			self.log.debug "Reached the end of the connections enum."
+			self.enum = nil
+			return nil
+		end
+
+
+		### Add a new conn_hash to the currrent batch. If the +conn_hash+'s connection
+		### is an exception, don't add it and just add an error status for it built from
+		### the exception.
+		def add_connection( conn_hash )
+			if conn_hash[:conn].is_a?( ::Exception )
+				self.log.debug "Adding an error result for %{identifier}." % conn_hash
+				self.results[ conn_hash[:identifier] ] = { error: conn_hash[:conn].message }
+			else
+				self.log.debug "Added connection for %{identifier} to the batch." % conn_hash
+				self.current_batch.push( conn_hash )
+				self.connection_hashes[ conn_hash[:conn] ] = conn_hash
+			end
+		end
+
+
+		### Remove the specified +conn_hash+ from the current batch.
+		def remove_connection( conn_hash )
+			self.current_batch.delete( conn_hash )
+			self.connection_hashes.delete( conn_hash[:conn] )
+		end
+
+
+		### Remove the connection hash for the specified +socket+ from the current
+		### batch and return it (if it was in the batch).
+		def remove_socket( socket )
+			conn_hash = self.connection_hashes.delete( socket )
+			self.current_batch.delete( conn_hash )
+
+			return conn_hash
+		end
+
+
+		### Fill the #current_batch if it's not yet at capacity and there are more
+		### connections to be made.
+		def fill_batch
+			# If the enum is not nil and the array isn't full, fetch a new connection
+			while self.enum && !self.batch_full?
+				self.log.debug "Adding connections to the queue."
+				conn_hash = self.next_connection or break
+				self.add_connection( conn_hash )
+			end
+		end
+
+
+		### Shift any connections which have timed out off of the current batch and
+		### return the timeout of the oldest non-timed-out connection.
+		def remove_timedout_connections
+			expired = self.current_batch.take_while do |conn_hash|
+				conn_hash[ :timeout_at ].past?
+			end
+
+			wait_seconds = if self.current_batch.empty?
+					1
+				else
+					self.current_batch.first[:timeout_at] - Time.now
+				end
+
+			expired.each do |conn_hash|
+				self.remove_connection( conn_hash )
+				self.log.debug "Discarding timed-out socket for %{identifier}." % conn_hash
+
+				elapsed = conn_hash[:timeout_at] - conn_hash[:start]
+				self.results[ conn_hash[:identifier] ] = {
+					error: "Timeout after %0.3fs" % [ elapsed ]
+				}
+			end
+
+			return wait_seconds.abs
+		end
+
+
+		### Wait at most +wait_seconds+ for one of the sockets in the current batch
+		### to become ready. If any are ready before the +wait_seconds+ have elapsed,
+		### returns them as an Array. If +wait_seconds+ goes by without any sockets becoming
+		### ready, or if there were no sockets to wait on, returns +nil+.
+		def wait_for_ready_connections( wait_seconds )
+			sockets = self.connection_hashes.keys
+			ready = nil
+
+			self.log.debug "Selecting on %d sockets." % [ sockets.length ]
+			_, ready, _ = IO.select( nil, sockets, nil, wait_seconds ) unless sockets.empty?
+
+			return ready
+		end
+
+
+		### Run the batch runner, yielding to the specified +block+ as each connection
+		### becomes ready.
+		def run( &block )
+			self.start = Time.now
+
+			until self.finished?
+				self.log.debug "Getting the status of %d connections." %
+					[ self.current_batch.length ]
+
+				self.fill_batch
+				wait_seconds = self.remove_timedout_connections
+				ready = self.wait_for_ready_connections( wait_seconds )
+
+				# If the select returns ready sockets
+				#   Build successful status for each ready socket
+				now = Time.now
+				ready.each do |sock|
+					conn_hash = self.remove_socket( sock ) or
+						raise "Ready socket %p was not in the current batch!" % [ sock ]
+
+					identifier, start = conn_hash.values_at( :identifier, :start )
+					duration = now - start
+
+					results[ identifier ] = block.call( conn_hash, duration )
+				end if ready
+			end
+
+			return Time.now - self.start
+		end
+
+	end # class BatchRunner
+
+
+	### Inclusion callback -- add the #batchsize attribute to including monitors.
+	def self::included( mod )
+		mod.attr_accessor :timeout
+		mod.attr_accessor :batch_size
+
+		super
+	end
+
+
+	### Return a clone of the receiving monitor with its batch size set to
+	### +new_size+.
+	def with_batch_size( new_size )
+		copy = self.clone
+		copy.batch_size = new_size
+		return copy
+	end
+
+
+	### Return a clone of receiving monitor with its timeout set to +new_timeout+.
+	def with_timeout( new_timeout )
+		copy = self.clone
+		copy.timeout = new_timeout
+		return copy
+	end
+
+
+	### Run the monitor, batching connections for the specified +nodes+ so the
+	### monitor doesn't exhaust its file descriptors.
+	def run( nodes )
+		connections = self.make_connections_enum( nodes )
+		return self.handle_connections( connections )
+	end
+
+
+	### Return an Enumerator that yields Hashes that describe the connections to be
+	### made. They must contain, at a minimum, the following keys:
+	###
+	### +conn+:: The Socket (or other IO object) that is used to communicate with the
+	###          monitored host. This should be created using non-blocking connection.
+	### +identifier+:: The node identifier associated with the +conn+.
+	###
+	### You can add any other members to each Hash that you require to actually use
+	### the connection when it becomes available.
+	def make_connections_enum( nodes )
+		raise "%p does not provide a %s method!" % [ __method__ ]
+	end
+
+
+	### Called when a socket becomes ready. It should generate a status update for
+	### the node that corresponds to the given +node_hash+ and return it as a Hash.
+	### The +duration+ is how long it took for the connection to be ready, in
+	### seconds.
+	def status_for_conn( conn_hash, duration )
+		raise "%p does not provide a %s method!" % [ __method__ ]
+	end
+
+
+	### Fetch connections from +connections_enum+ and build a Hash of node updates
+	### keyed by identifier based on the results.
+	def handle_connections( connections_enum )
+		runner = BatchRunner.new( connections_enum, self.batch_size, self.timeout )
+		runner.run do |conn_hash, duration|
+			self.status_for_conn( conn_hash, duration )
+		end
+		return runner.results
+	end
+
+end # module Arborist::Monitor::ConnectionBatching
+
+

data/lib/arborist/monitor/socket.rb

@@ -7,23 +7,36 @@ require 'timeout'
 require 'socket'
 
 require 'arborist/monitor' unless defined?( Arborist::Monitor )
-
-using Arborist::TimeRefinements
+require 'arborist/monitor/connection_batching'
 
 
 # Socket-related Arborist monitor logic
 module Arborist::Monitor::Socket
+	extend Configurability
+
+
+	configurability( 'arborist.monitors.socket' ) do
+
+		##
+		# The default timeout employed by the socket monitors, in floating-point
+		# seconds.
+		setting :default_timeout, default: 2.0 do |val|
+			Float( val )
+		end
+
+	end
+
 
 	# Arborist TCP socket monitor logic
 	class TCP
 		extend Loggability
+		include Arborist::Monitor::ConnectionBatching
+
 		log_to :arborist
 
 
-		# Defaults for instances of this monitor
-		DEFAULT_OPTIONS = {
-			timeout: 2.seconds
-		}
+		# Always request the node addresses and port.
+		USED_PROPERTIES = [ :addresses, :port ].freeze
 
 
 		### Instantiate a monitor check and run it for the specified +nodes+.
@@ -32,16 +45,18 @@ module Arborist::Monitor::Socket
 		end
 
 
+		### Return the properties used by this monitor.
+		def self::node_properties
+			return USED_PROPERTIES
+		end
+
+
 		### Create a new TCP monitor with the specified +options+. Valid options are:
 		###
 		### +:timeout+
 		###   Set the number of seconds to wait for a connection for each node.
-		def initialize( options=DEFAULT_OPTIONS )
-			options = DEFAULT_OPTIONS.merge( options || {} )
-
-			options.each do |name, value|
-				self.public_send( "#{name}=", value )
-			end
+		def initialize( timeout: Arborist::Monitor::Socket.default_timeout )
+			self.timeout = timeout
 		end
 
 
@@ -49,33 +64,11 @@ module Arborist::Monitor::Socket
 		public
 		######
 
-		# The timeout for connecting, in seconds.
-		attr_accessor :timeout
-
-
-		### Run the TCP check for each of the specified Hash of +nodes+ and return a Hash of
-		### updates for them based on trying to connect to them.
-		def run( nodes )
-			self.log.debug "Got nodes to TCP check: %p" % [ nodes ]
-
-			connections = self.make_connections( nodes )
-			return self.wait_for_connections( connections )
-		end
-
-
-		### Return a clone of this object with its timeout set to +new_timeout+.
-		def with_timeout( new_timeout )
-			copy = self.clone
-			copy.timeout = new_timeout
-			return copy
-		end
-
-
-		### Open a socket for each of the specified nodes using non-blocking connect(2), and
-		### return a Hash of the sockets (or the error from the connection attempt) keyed by
-		### node identifier.
-		def make_connections( nodes )
-			return nodes.each_with_object( {} ) do |(identifier, node_data), accum|
+		### Return an Enumerator that lazily yields Hashes of the form expected by the
+		### ConnectionBatching mixin for each of the specified +nodes+.
+		def make_connections_enum( nodes )
+			return nodes.lazy.map do |identifier, node_data|
+				self.log.debug "Creating a socket for %s" % [ identifier ]
 
 				# :TODO: Should this try all the addresses? Should you be able to specify an
 				# address for a Service?
@@ -89,6 +82,7 @@ module Arborist::Monitor::Socket
 				conn = begin
 						sockaddr = Socket.sockaddr_in( port, address )
 						sock.connect_nonblock( sockaddr )
+						sock
 					rescue Errno::EINPROGRESS
 						self.log.debug "  connection started"
 						sock
@@ -97,74 +91,40 @@ module Arborist::Monitor::Socket
 						err
 					end
 
-				accum[ conn ] = [ identifier, sockaddr ]
+				{ conn: conn, identifier: identifier }
 			end
 		end
 
 
-		### For any elements of +connections+ that are sockets, wait on them to complete or error
-		### and then return a Hash of node updates keyed by identifier based on the results.
-		def wait_for_connections( connections )
-			results = {}
-			start = Time.now
-			timeout_at = Time.now + self.timeout
-
-			# First strip out all the ones that failed in the first #connect_nonblock
-			connections.delete_if do |sock, (identifier, _)|
-				next false if sock.respond_to?( :connect_nonblock ) # Keep sockets
-				self.log.debug "  removing connect error for node %s" % [ identifier ]
-				results[ identifier ] = { error: sock.message }
-			end
-
-			# Now wait for connections to complete
-			wait_seconds = timeout_at - Time.now
-			until connections.empty? || wait_seconds <= 0
-				self.log.debug "Waiting on %d connections for %0.3fs..." %
-					[ connections.values.length, wait_seconds ]
-
-				_, ready, _ = IO.select( nil, connections.keys, nil, wait_seconds )
-
-				now = Time.now
-				ready.each do |sock|
-					identifier, sockaddr = *connections.delete( sock )
-
-					begin
-						res = sock.getpeername
-						self.log.debug "connected to %s" % [ identifier ]
-						results[ identifier ] = {
-							tcp_socket_connect: { time: now.iso8601, duration: now - start }
-						}
-					rescue SocketError, SystemCallError => err
-						begin
-							sock.read( 1 )
-						rescue => err
-							self.log.debug "read: %p: %s" % [ err.class, err.message ]
-							results[ identifier ] = { error: err.message }
-						end
-					ensure
-						sock.close
-					end
-
-				end if ready
-
-				wait_seconds = timeout_at - Time.now
-			end
-
-			# Anything left is a timeout
-			connections.each do |sock, (identifier, _)|
-				self.log.debug "%s: timeout (no connection in %0.3ds)" % [ identifier, self.timeout ]
-				results[ identifier ] = { error: "Timeout after %0.3fs" % [self.timeout] }
-				sock.close
+		### Build a status for the specified +conn_hash+ after its :conn has indicated
+		### it is ready.
+		def status_for_conn( conn_hash, duration )
+			sock = conn_hash[:conn]
+			# Why getpeername? Testing socket success without read()ing, I think?
+			# FreeBSD source?
+			res = sock.getpeername
+			return {
+				tcp_socket_connect: { duration: duration }
+			}
+		rescue SocketError, SystemCallError => err
+			self.log.debug "Got %p while connecting to %s" % [ err.class, conn_hash[:identifier] ]
+			begin
+				sock.read( 1 )
+			rescue => err
+				return { error: err.message }
 			end
-
-			return results
+		ensure
+			sock.close if sock
 		end
+
 	end # class TCP
 
 
 	# Arborist UDP socket monitor logic
 	class UDP
 		extend Loggability
+		include Arborist::Monitor::ConnectionBatching
+
 		log_to :arborist
 
 
@@ -173,6 +133,9 @@ module Arborist::Monitor::Socket
 			timeout: 0.001
 		}
 
+		# Always request the node addresses and port.
+		USED_PROPERTIES = [ :addresses, :port ].freeze
+
 
 		### Instantiate a monitor check and run it for the specified +nodes+.
 		def self::run( nodes )
@@ -180,16 +143,18 @@ module Arborist::Monitor::Socket
 		end
 
 
+		### Return the properties used by this monitor.
+		def self::node_properties
+			return USED_PROPERTIES
+		end
+
+
 		### Create a new UDP monitor with the specified +options+. Valid options are:
 		###
 		### +:timeout+
 		###   Set the number of seconds to wait for a connection for each node.
-		def initialize( options=DEFAULT_OPTIONS )
-			options = DEFAULT_OPTIONS.merge( options || {} )
-
-			options.each do |name, value|
-				self.public_send( "#{name}=", value )
-			end
+		def initialize( timeout: Arborist::Monitor::Socket.default_timeout )
+			self.timeout = timeout
 		end
 
 
@@ -197,26 +162,11 @@ module Arborist::Monitor::Socket
 		public
 		######
 
-		# The timeout for connecting, in seconds.
-		attr_accessor :timeout
-
-
-		### Run the UDP check for each of the specified Hash of +nodes+ and return a Hash of
-		### updates for them based on trying to connect to them.
-		def run( nodes )
-			self.log.debug "Got nodes to UDP check: %p" % [ nodes ]
-
-			connections = self.make_connections( nodes )
-			return self.wait_for_connections( connections )
-		end
-
-
 		### Open a socket for each of the specified nodes and return a Hash of
 		### the sockets (or the error from the connection attempt) keyed by
 		### node identifier.
-		def make_connections( nodes )
-			return nodes.each_with_object( {} ) do |(identifier, node_data), accum|
-
+		def make_connections_enum( nodes )
+			return nodes.lazy.map do |identifier, node_data|
 				address = node_data['addresses'].first
 				port = node_data['port']
 
@@ -224,61 +174,45 @@ module Arborist::Monitor::Socket
 				sock = Socket.new( :INET, :DGRAM )
 
 				conn = begin
-					sockaddr = Socket.sockaddr_in( port, address )
-					sock.connect( sockaddr )
-					sock.send( '', 0 )
-					sock
-				rescue SocketError => err
-					self.log.error "  %p setting up connection: %s" % [ err.class, err.message ]
-					err
-				end
-
-				accum[ conn ] = [ identifier, sock ]
-			end
-		end
-
-
-		### For any elements of +connections+ that are sockets, wait on them to complete or error
-		### and then return a Hash of node updates keyed by identifier based on the results.
-		def wait_for_connections( connections )
-			results = {}
-			start = Time.now
+						sockaddr = Socket.sockaddr_in( port, address )
+						sock.connect( sockaddr )
+						sock.send( '', 0 )
+						sock.recvfrom_nonblock( 1 )
+						sock
+					rescue Errno::EAGAIN
+						self.log.debug "  connection started"
+						sock
+					rescue => err
+						self.log.error "  %p setting up connection: %s" % [ err.class, err.message ]
+						err
+					end
 
-			# First strip out all the ones that failed in the first #connect
-			connections.delete_if do |sock, (identifier, _)|
-				next false if sock.respond_to?( :recvfrom_nonblock ) # Keep sockets
-				self.log.debug "  removing connect error for node %s" % [ identifier ]
-				results[ identifier ] = { error: sock.message }
+				self.log.debug "UDP connection object is: %p" % [ conn ]
+				{ conn: conn, identifier: identifier }
 			end
+		end
 
-			# Test all connections
-			connections.each do |sock, (identifier, _)|
-				begin
-					sock.recvfrom_nonblock( 1 )
-
-				rescue IO::WaitReadable
-					ready, _, _ = IO.select( [sock], [], [], self.timeout )
-					if ready.nil?
-						now = Time.now
-						results[ identifier ] = {
-							udp_socket_connect: { time: now.iso8601, duration: now - start }
-						}
-						self.log.debug "  connection successful"
-					else
-						retry
-					end
 
-				rescue SocketError, SystemCallError => err
-					self.log.debug "%p during connection: %s" % [ err.class, err.message ]
-					results[ identifier ] = { error: err.message }
+		### Build a status for the specified +conn_hash+ after its :conn has indicated
+		### it is ready.
+		def status_for_conn( conn_hash, duration )
+			sock = conn_hash[:conn]
+			sock.recvfrom_nonblock( 1 )
+			return {
+				udp_socket_connect: { duration: duration }
+			}
+		rescue Errno::EAGAIN
+			return {
+				udp_socket_connect: { duration: duration }
+			}
+		rescue SocketError, SystemCallError => err
+			self.log.debug "Got %p while connecting to %s" % [ err.class, conn_hash[:identifier] ]
+			return { error: err.message }
+		ensure
+			sock.close if sock
+		end
 
-				ensure
-					sock.close
-				end
-			end
 
-			return results
-		end
 	end # class UDP