Class: Arborist::Monitor::Socket::TCP

Inherits:
Object
  • Object
show all
Extended by:
Loggability
Includes:
ConnectionBatching
Defined in:
lib/arborist/monitor/socket.rb

Overview

Arborist TCP socket monitor logic

Constant Summary collapse

USED_PROPERTIES =

Always request the node addresses and port.

[ :addresses, :port ].freeze

Constants included from ConnectionBatching

ConnectionBatching::DEFAULT_BATCH_SIZE, ConnectionBatching::DEFAULT_TIMEOUT

Class Method Summary collapse

Instance Method Summary collapse

Methods included from ConnectionBatching

#handle_connections, included, #run, #with_batch_size, #with_timeout

Constructor Details

#initialize(timeout: Arborist::Monitor::Socket.default_timeout, batch_size: Arborist::Monitor::Socket.batch_size) ⇒ TCP

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.

:batch_size

The number of UDP connection attempts to perform simultaneously.



65
66
67
68
 
# File 'lib/arborist/monitor/socket.rb', line 65

def initialize( timeout: Arborist::Monitor::Socket.default_timeout, batch_size: Arborist::Monitor::Socket.batch_size )
	self.timeout = timeout
	self.batch_size = batch_size
end

Class Method Details

.node_properties ⇒ Object

Return the properties used by this monitor.



54
55
56
 
# File 'lib/arborist/monitor/socket.rb', line 54

def self::node_properties
	return USED_PROPERTIES
end

.run(nodes) ⇒ Object

Instantiate a monitor check and run it for the specified nodes.



48
49
50
 
# File 'lib/arborist/monitor/socket.rb', line 48

def self::run( nodes )
	return self.new.run( nodes )
end

Instance Method Details

#make_connections_enum(nodes) ⇒ Object

Return an Enumerator that lazily yields Hashes of the form expected by the ConnectionBatching mixin for each of the specified nodes.



77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
 
# File 'lib/arborist/monitor/socket.rb', line 77

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?
		address = node_data['addresses'].first
		port = node_data['port']
		sockaddr = nil

		self.log.debug "Creating TCP connection for %s:%d" % [ address, port ]
		sock = Socket.new( :INET, :STREAM )

		conn = begin
				sockaddr = Socket.sockaddr_in( port, address )
				sock.connect_nonblock( sockaddr )
				sock
			rescue Errno::EINPROGRESS
				self.log.debug "  connection started"
				sock
			rescue => err
				self.log.error "  %p setting up connection: %s" % [ err.class, err.message ]
				err
			end

		{ conn: conn, identifier: identifier }
	end
end

#status_for_conn(conn_hash, duration) ⇒ Object

Build a status for the specified conn_hash after its :conn has indicated it is ready.



109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
 
# File 'lib/arborist/monitor/socket.rb', line 109

def status_for_conn( conn_hash, duration )
	sock = conn_hash[:conn]
	# Why getpeername? Testing socket success without read()ing, I think?
	# FreeBSD source?
	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
ensure
	sock.close if sock
end