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
|
require 'tsort'
module LeapCli
module Config
#
# A list of Config::Object instances (internally stored as a hash)
#
class ObjectList < Hash
include TSort
def initialize(config=nil)
if config
self.add(config['name'], config)
end
end
#
# If the key is a string, the Config::Object it references is returned.
#
# If the key is a hash, we treat it as a condition and filter all the Config::Objects using the condition.
# A new ObjectList is returned.
#
# Examples:
#
# nodes['vpn1']
# node named 'vpn1'
#
# nodes[:public_dns => true]
# all nodes with public dns
#
# nodes[:services => 'openvpn', 'location.country_code' => 'US']
# all nodes with services containing 'openvpn' OR country code of US
#
# Sometimes, you want to do an OR condition with multiple conditions
# for the same field. Since hash keys must be unique, you can use
# an array representation instead:
#
# nodes[[:services, 'openvpn'], [:services, 'tor']]
# nodes with openvpn OR tor service
#
# nodes[:services => 'openvpn'][:tags => 'production']
# nodes with openvpn AND are production
#
def [](key)
if key.is_a?(Hash) || key.is_a?(Array)
filter(key)
else
super key.to_s
end
end
def exclude(node)
list = self.dup
list.delete(node.name)
return list
end
def each_node(&block)
self.keys.sort.each do |node_name|
yield self[node_name]
end
end
#
# filters this object list, producing a new list.
# filter is an array or a hash. see []
#
def filter(filter)
results = Config::ObjectList.new
filter.each do |field, match_value|
field = field.is_a?(Symbol) ? field.to_s : field
match_value = match_value.is_a?(Symbol) ? match_value.to_s : match_value
if match_value.is_a?(String) && match_value =~ /^!/
operator = :not_equal
match_value = match_value.sub(/^!/, '')
else
operator = :equal
end
each do |name, config|
value = config[field]
if value.is_a? Array
if operator == :equal && value.include?(match_value)
results[name] = config
elsif operator == :not_equal && !value.include?(match_value)
results[name] = config
end
else
if operator == :equal && value == match_value
results[name] = config
elsif operator == :not_equal && value != match_value
results[name] = config
end
end
end
end
results
end
def add(name, object)
self[name] = object
end
#
# converts the hash of configs into an array of hashes, with ONLY the specified fields
#
def fields(*fields)
result = []
keys.sort.each do |name|
result << self[name].pick(*fields)
end
result
end
#
# like fields(), but returns an array of values instead of an array of hashes.
#
def field(field)
field = field.to_s
result = []
keys.sort.each do |name|
result << self[name].get(field)
end
result
end
#
# pick_fields(field1, field2, ...)
#
# generates a Hash from the object list, but with only the fields that are picked.
#
# If there are more than one field, then the result is a Hash of Hashes.
# If there is just one field, it is a simple map to the value.
#
# For example:
#
# "neighbors" = "= nodes_like_me[:services => :couchdb].pick_fields('domain.full', 'ip_address')"
#
# generates this:
#
# neighbors:
# couch1:
# domain_full: couch1.bitmask.net
# ip_address: "10.5.5.44"
# couch2:
# domain_full: couch2.bitmask.net
# ip_address: "10.5.5.52"
#
# But this:
#
# "neighbors": "= nodes_like_me[:services => :couchdb].pick_fields('domain.full')"
#
# will generate this:
#
# neighbors:
# couch1: couch1.bitmask.net
# couch2: couch2.bitmask.net
#
def pick_fields(*fields)
self.values.inject({}) do |hsh, node|
value = self[node.name].pick(*fields)
if fields.size == 1
value = value.values.first
end
hsh[node.name] = value
hsh
end
end
#
# applies inherit_from! to all objects.
#
def inherit_from!(object_list)
object_list.each do |name, object|
if self[name]
self[name].inherit_from!(object)
else
self[name] = object.deep_dup
end
end
end
#
# topographical sort based on test dependency
#
def tsort_each_node(&block)
self.each_key(&block)
end
def tsort_each_child(node_name, &block)
if self[node_name]
self[node_name].test_dependencies.each do |test_me_first|
if self[test_me_first] # TODO: in the future, allow for ability to optionally pull in all dependencies.
# not just the ones that pass the node filter.
yield(test_me_first)
end
end
end
end
def names_in_test_dependency_order
self.tsort
end
end
end
end
|
