/
provider.rb
208 lines (176 loc) · 5.94 KB
/
provider.rb
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
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
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
# Providers present a lightweight wrapper for various third-party services,
# such as Chef's node and client APIs, and Amazon's EC2 APIs. This allows
# Ironfan ask specialized questions (such as whether a given resource
# matches
module Ironfan
class Provider < Builder
class_attribute :handle
def self.receive(obj, &block)
if obj.is_a?(Hash)
obj = obj.symbolize_keys
obj[:_type] =
case obj[:name]
when :chef then Chef
when :ec2 then Ec2
when :virtualbox then VirtualBox
else raise "Unsupported provider #{obj[:name]}"
end
end
super
end
def resources() self.class.resources; end
def self.resources
raise "missing #{self.class}.resources declaration"
end
#
# Discovery
#
def self.load(cluster)
Ironfan.parallel (resources) do |r|
type = r.resource_type.to_s
r.forget!
Ironfan.substep(cluster.name, "loading #{type}s")
r.load! cluster
Ironfan.substep(cluster.name, "loaded #{type}s")
end
end
def self.validate(computers)
resources.each {|r| r.validate_resources! computers }
end
def self.prepare!(computers)
resources.each do |r|
r.prepare!(computers) if r.shared?
end
end
def self.aggregate!(computers)
resources.each do |r|
r.aggregate!(computers) if r.shared?
end
end
class Resource < Builder
@@known = {}
field :adaptee, Whatever
field :bogus, Array, :default => []
attr_accessor :owner
attr_accessor :users
def users() @users ||= []; end;
def bogus?() !bogus.empty?; end
def self.handle ; name.to_s.gsub(/.*::/,'').to_sym ; end
def self.receive(obj)
obj = obj.symbolize_keys if obj.is_a?(Hash)
super(obj)
end
#
# Flags
#
# Non-shared resources live and die with the computer
def self.shared?() true; end
# Can multiple instances of this resource be associated with the computer?
def self.multiple?() false; end
#
# Discovery
#
def self.load!(*p) Ironfan.noop(self,__method__,*p); end
def self.validate_computer!(*p) Ironfan.noop(self,__method__,*p); end
def self.validate_resources!(*p) Ironfan.noop(self,__method__,*p); end
def on_correlate(*p) Ironfan.noop(self,__method__,*p); end
#
# Manipulation
#
def self.create!(*p) Ironfan.noop(self,__method__,*p); end
def self.save!(*p) Ironfan.noop(self,__method__,*p); end
def self.prepare!(*p) Ironfan.noop(self,__method__,*p); end
def self.aggregate!(*p) Ironfan.noop(self,__method__,*p); end
def self.destroy!(*p) Ironfan.noop(self,__method__,*p); end
#
# Utilities
#
[:shared?, :multiple?, :load!,:validate_computer!, :validate_resources!,
:create!, :save!, :prepare!, :aggregate!, :destroy!].each do |method_name|
define_method(method_name) {|*p| self.class.send(method_name,*p) }
end
def self.remember(resource,options={})
index = options[:id] || resource.name
index += options[:append_id] if options[:append_id]
self.known[index] = resource
end
# Register and return the (adapted) object with the collection
def self.register(native)
result = new(:adaptee => native) or return
remember result
result
end
def self.recall?(id)
self.known.include? id
end
def self.recall(id=nil)
return self.known if id.nil?
self.known[id]
end
def self.forget!
@@known[self.name] = { }
end
def self.forget(id)
self.known.delete(id)
end
# Provide a separate namespace in @@known for each subclass
def self.known
@@known[self.name] ||= {}
end
def self.patiently(name, error_class, options={})
options[:message] ||= 'ignoring %s'
options[:wait_time] ||= 1
options[:max_tries] ||= 10
success = false
tries = 0
until success or (tries > options[:max_tries]) do
begin
result = yield
success = true # If we made it to this line, the yield didn't raise an exception
rescue error_class => e
tries += 1
if options[:ignore] and options[:ignore].call(e)
success = true
Ironfan.substep(name, options[:message] % e.message, options[:display] ? :red : :gray)
else
Ironfan.substep(name, options[:message] % e.message, options[:display] ? :red : :gray)
Ironfan.substep(name, "sleeping #{options[:sleep_time]} second(s) before trying again")
sleep options[:wait_time]
result = e
end
end
end
if success
return result
else
ui.warn("Gave up after #{options[:max_tries]} attempts to execute #{name} code")
raise result
end
end
end
end
class IaasProvider < Provider
def self.machine_class
self.const_get(:Machine)
end
#
# Manipulation
#
def ensure_prerequisites!(computers)
# Create all things that aren't machines
targets = resources.reject {|type| type < IaasProvider::Machine}
computers.each do |computer|
targets.each {|r| r.create! computer }
end
end
def save!(computers)
computers.each do |computer|
targets.each {|r| r.save! computer }
end
end
class Machine < Resource
# A Machine lives and dies with its Computer
def self.shared?() false; end
end
end
end