Class: Async::IO::Endpoint

Inherits:
Object
  • Object
show all
Defined in:
lib/async/io/endpoint.rb,
lib/async/io/ssl_endpoint.rb,
lib/async/io/endpoint/each.rb,
lib/async/io/host_endpoint.rb,
lib/async/io/unix_endpoint.rb,
lib/async/io/socket_endpoint.rb,
lib/async/io/composite_endpoint.rb

Overview

Endpoints represent a way of connecting or binding to an address.

Instance Attribute Summary collapse

Class Method Summary collapse

Instance Method Summary collapse

Constructor Details

#initialize(**options) ⇒ Endpoint

Returns a new instance of Endpoint.



16
17
18
 
# File 'lib/async/io/endpoint.rb', line 16

def initialize(**options)
	@options = options.freeze
end

Instance Attribute Details

#options ⇒ Object

Returns the value of attribute options.



28
29
30
 
# File 'lib/async/io/endpoint.rb', line 28

def options
  @options
end

Class Method Details

.composite(*endpoints, **options) ⇒ Object 



39
40
41
 
# File 'lib/async/io/composite_endpoint.rb', line 39

def self.composite(*endpoints, **options)
	CompositeEndpoint.new(endpoints, **options)
end

.each(specifications, &block) ⇒ Object

Generate a list of endpoints from an array.



31
32
33
34
35
36
37
 
# File 'lib/async/io/endpoint/each.rb', line 31

def self.each(specifications, &block)
	return to_enum(:each, specifications) unless block_given?
	
	specifications.each do |specification|
		yield try_convert(specification)
	end
end

.parse(string, **options) ⇒ Object

Create an Endpoint instance by URI scheme. The host and port of the URI will be passed to the Endpoint factory method, along with any options.

Parameters:

  • string (String) —

    URI as string. Scheme will decide implementation used.

  • options —

    keyword arguments passed through to #initialize

See Also:



107
108
109
110
111
 
# File 'lib/async/io/endpoint.rb', line 107

def self.parse(string, **options)
	uri = URI.parse(string)
	
	self.public_send(uri.scheme, uri.host, uri.port, **options)
end

.socket(socket, **options) ⇒ Object 



51
52
53
 
# File 'lib/async/io/socket_endpoint.rb', line 51

def self.socket(socket, **options)
	SocketEndpoint.new(socket, **options)
end

.ssl(*args, ssl_context: nil, hostname: nil, **options) ⇒ SSLEndpoint

Parameters:

  • args
  • ssl_context (OpenSSL::SSL::SSLContext, nil) (defaults to: nil)
  • hostname (String, nil) (defaults to: nil)
  • options —

    keyword arguments passed through to tcp

Returns:



98
99
100
 
# File 'lib/async/io/ssl_endpoint.rb', line 98

def self.ssl(*args, ssl_context: nil, hostname: nil, **options)
	SSLEndpoint.new(self.tcp(*args, **options), ssl_context: ssl_context, hostname: hostname)
end

.tcp(*args, **options) ⇒ HostEndpoint

Parameters:

  • args —

    nodename, service, family, socktype, protocol, flags. ‘socktype` will be set to Socket::SOCK_STREAM.

  • options —

    keyword arguments passed on to HostEndpoint#initialize

Returns:



85
86
87
88
89
 
# File 'lib/async/io/host_endpoint.rb', line 85

def self.tcp(*args, **options)
	args[3] = ::Socket::SOCK_STREAM
	
	HostEndpoint.new(args, **options)
end

.try_convert(specification) ⇒ Object 



14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
 
# File 'lib/async/io/endpoint/each.rb', line 14

def self.try_convert(specification)
	if specification.is_a? self
		specification
	elsif specification.is_a? Array
		self.send(*specification)
	elsif specification.is_a? String
		self.parse(specification)
	elsif specification.is_a? ::BasicSocket
		self.socket(specification)
	elsif specification.is_a? Generic
		self.new(specification)
	else
		raise ArgumentError.new("Not sure how to convert #{specification} to endpoint!")
	end
end

.udp(*args, **options) ⇒ HostEndpoint

Parameters:

  • args —

    nodename, service, family, socktype, protocol, flags. ‘socktype` will be set to Socket::SOCK_DGRAM.

  • options —

    keyword arguments passed on to HostEndpoint#initialize

Returns:



95
96
97
98
99
 
# File 'lib/async/io/host_endpoint.rb', line 95

def self.udp(*args, **options)
	args[3] = ::Socket::SOCK_DGRAM
	
	HostEndpoint.new(args, **options)
end

.unix(path = "", type = ::Socket::SOCK_STREAM, **options) ⇒ UNIXEndpoint

Parameters:

  • path (String) (defaults to: "")
  • type (defaults to: ::Socket::SOCK_STREAM) —

    Socket type

  • options —

    keyword arguments passed through to UNIXEndpoint#initialize

Returns:



53
54
55
 
# File 'lib/async/io/unix_endpoint.rb', line 53

def self.unix(path = "", type = ::Socket::SOCK_STREAM, **options)
	UNIXEndpoint.new(path, type, **options)
end

Instance Method Details

#accept(backlog = Socket::SOMAXCONN, &block) ⇒ Object

Accept connections from the specified endpoint.

Parameters:

  • backlog (Integer) (defaults to: Socket::SOMAXCONN) —

    the number of connections to listen for.



73
74
75
76
77
78
79
 
# File 'lib/async/io/endpoint.rb', line 73

def accept(backlog = Socket::SOMAXCONN, &block)
	bind do |server|
		server.listen(backlog)
		
		server.accept_each(&block)
	end
end

#bound { ... } ⇒ Object

Map all endpoints by invoking ‘#bind`.

Yields:

  • the bound wrapper.



83
84
85
86
87
88
89
90
91
92
93
94
95
96
 
# File 'lib/async/io/endpoint.rb', line 83

def bound
	wrappers = []
	
	self.each do |endpoint|
		wrapper = endpoint.bind
		wrappers << wrapper
		
		yield wrapper
	end
	
	return wrappers
ensure
	wrappers.each(&:close) if $!
end

#each {|Endpoint| ... } ⇒ Object

Endpoints sometimes have multiple paths.

Yields:

  • (Endpoint) —

    Enumerate all discrete paths as endpoints.



65
66
67
68
69
 
# File 'lib/async/io/endpoint.rb', line 65

def each
	return to_enum unless block_given?
	
	yield self
end

#hostname ⇒ String

Returns The hostname of the bound socket.

Returns:

  • (String) —

    The hostname of the bound socket.



31
32
33
 
# File 'lib/async/io/endpoint.rb', line 31

def hostname
	@options[:hostname]
end

#linger ⇒ Integer?

Controls SO_LINGER. The amount of time the socket will stay in the ‘TIME_WAIT` state after being closed.

Returns:

  • (Integer, nil) —

    The value for SO_LINGER.



49
50
51
 
# File 'lib/async/io/endpoint.rb', line 49

def linger
	@options[:linger]
end

#local_address ⇒ Address

Returns the address to bind to before connecting.

Returns:

  • (Address) —

    the address to bind to before connecting.



59
60
61
 
# File 'lib/async/io/endpoint.rb', line 59

def local_address
	@options[:local_address]
end

#reuse_address ⇒ Boolean

If ‘SO_REUSEADDR` is enabled on a socket prior to binding it, the socket can be successfully bound unless there is a conflict with another socket bound to exactly the same combination of source address and port. Additionally, when set, binding a socket to the address of an existing socket in `TIME_WAIT` is not an error.

Returns:

  • (Boolean) —

    The value for ‘SO_REUSEADDR`.



43
44
45
 
# File 'lib/async/io/endpoint.rb', line 43

def reuse_address
	@options[:reuse_address]
end

#reuse_port ⇒ Boolean?

If ‘SO_REUSEPORT` is enabled on a socket, the socket can be successfully bound even if there are existing sockets bound to the same address, as long as all prior bound sockets also had `SO_REUSEPORT` set before they were bound.

Returns:

  • (Boolean, nil) —

    The value for ‘SO_REUSEPORT`.



37
38
39
 
# File 'lib/async/io/endpoint.rb', line 37

def reuse_port
	@options[:reuse_port]
end

#timeout ⇒ Numeric

Returns The default timeout for socket operations.

Returns:

  • (Numeric) —

    The default timeout for socket operations.



54
55
56
 
# File 'lib/async/io/endpoint.rb', line 54

def timeout
	@options[:timeout]
end

#with(**options) ⇒ Object 



20
21
22
23
24
25
26
 
# File 'lib/async/io/endpoint.rb', line 20

def with(**options)
	dup = self.dup
	
	dup.options = @options.merge(options)
	
	return dup
end