Class: Async::Pool::Controller

Inherits:
Object
  • Object
show all
Defined in:
lib/async/pool/controller.rb

Instance Attribute Summary collapse

Class Method Summary collapse

Instance Method Summary collapse

Constructor Details

#initialize(constructor, limit: nil) ⇒ Controller

Returns a new instance of Controller.



33
34
35
36
37
38
39
40
41
42
43
 
# File 'lib/async/pool/controller.rb', line 33

def initialize(constructor, limit: nil)
	@resources = {}
	
	@available = []
	@notification = Async::Notification.new
	
	@limit = limit
	
	@constructor = constructor
	@guard = Async::Semaphore.new(1)
end

Instance Attribute Details

#resources ⇒ Object (readonly) 



46
47
48
 
# File 'lib/async/pool/controller.rb', line 46

def resources
  @resources
end

Class Method Details

.wrap(**options, &block) ⇒ Object 



29
30
31
 
# File 'lib/async/pool/controller.rb', line 29

def self.wrap(**options, &block)
	self.new(block, **options)
end

Instance Method Details

#acquire ⇒ Object 



75
76
77
78
79
80
81
82
83
84
85
 
# File 'lib/async/pool/controller.rb', line 75

def acquire
	resource = wait_for_resource
	
	return resource unless block_given?
	
	begin
		yield resource
	ensure
		release(resource)
	end
end

#active? ⇒ Boolean

Whether the pool has any active resources.

Returns:

  • (Boolean) 


53
54
55
 
# File 'lib/async/pool/controller.rb', line 53

def active?
	!@resources.empty?
end

#busy? ⇒ Boolean

Whether there are resources which are currently in use.

Returns:

  • (Boolean) 


58
59
60
61
62
63
64
 
# File 'lib/async/pool/controller.rb', line 58

def busy?
	@resources.collect do |_, usage|
		return true if usage > 0
	end
	
	return false
end

#close ⇒ Object 



97
98
99
100
 
# File 'lib/async/pool/controller.rb', line 97

def close
	@resources.each_key(&:close)
	@resources.clear
end

#empty? ⇒ Boolean

Returns:

  • (Boolean) 


71
72
73
 
# File 'lib/async/pool/controller.rb', line 71

def empty?
	@resources.empty?
end

#prune(retain = 0) ⇒ Object

Retire (and close) all unused resources. If a block is provided, it should implement the desired functionality for unused resources.

Parameters:

  • retain (Integer) (defaults to: 0) —

    the minimum number of resources to retain.



113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
 
# File 'lib/async/pool/controller.rb', line 113

def prune(retain = 0)
	unused = []
	
	@resources.each do |resource, usage|
		unused << resource if usage.zero?
	end
	
	unused.each do |resource|
		if block_given?
			yield resource
		else
			retire(resource)
		end
		
		break if @resources.size <= retain
	end
	
	return unused.size
end

#release(resource) ⇒ Object

Make the resource resources and let waiting tasks know that there is something resources.



88
89
90
91
92
93
94
95
 
# File 'lib/async/pool/controller.rb', line 88

def release(resource)
	# A resource that is not good should also not be reusable.
	if resource.reusable?
		reuse(resource)
	else
		retire(resource)
	end
end

#retire(resource) ⇒ Object 



133
134
135
136
137
138
139
140
141
 
# File 'lib/async/pool/controller.rb', line 133

def retire(resource)
	Async.logger.debug(self) {"Retire #{resource}"}
	
	@resources.delete(resource)
	
	resource.close
	
	@notification.signal
end

#size ⇒ Object 



48
49
50
 
# File 'lib/async/pool/controller.rb', line 48

def size
	@resources.size
end

#to_s ⇒ Object 



102
103
104
105
106
107
108
 
# File 'lib/async/pool/controller.rb', line 102

def to_s
	if @resources.empty?
		"\#<#{self.class}(#{usage_string})>"
	else
		"\#<#{self.class}(#{usage_string}) #{availability_string}>"
	end
end

#wait ⇒ Object

Wait until a pool resource has been freed.



67
68
69
 
# File 'lib/async/pool/controller.rb', line 67

def wait
	@notification.wait
end