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
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
|
require 'puppet'
require 'puppet/rails/param_name'
require 'puppet/rails/param_value'
require 'puppet/rails/puppet_tag'
require 'puppet/rails/benchmark'
require 'puppet/util/rails/collection_merger'
class Puppet::Rails::Resource < ActiveRecord::Base
include Puppet::Util::CollectionMerger
include Puppet::Util::ReferenceSerializer
include Puppet::Rails::Benchmark
has_many :param_values, :dependent => :destroy, :class_name => "Puppet::Rails::ParamValue"
has_many :param_names, :through => :param_values, :class_name => "Puppet::Rails::ParamName"
has_many :resource_tags, :dependent => :destroy, :class_name => "Puppet::Rails::ResourceTag"
has_many :puppet_tags, :through => :resource_tags, :class_name => "Puppet::Rails::PuppetTag"
belongs_to :source_file
belongs_to :host
@tags = {}
def self.tags
@tags
end
# Determine the basic details on the resource.
def self.rails_resource_initial_args(resource)
result = [:type, :title, :line].inject({}) do |hash, param|
# 'type' isn't a valid column name, so we have to use another name.
to = (param == :type) ? :restype : param
if value = resource.send(param)
hash[to] = value
end
hash
end
# We always want a value here, regardless of what the resource has,
# so we break it out separately.
result[:exported] = resource.exported || false
result
end
def add_resource_tag(tag)
pt = Puppet::Rails::PuppetTag.accumulate_by_name(tag)
resource_tags.build(:puppet_tag => pt)
end
def file
(f = self.source_file) ? f.filename : nil
end
def file=(file)
self.source_file = Puppet::Rails::SourceFile.find_or_create_by_filename(file)
end
def title
unserialize_value(self[:title])
end
def params_list
@params_list ||= []
end
def params_list=(params)
@params_list = params
end
def add_param_to_list(param)
params_list << param
end
def tags_list
@tags_list ||= []
end
def tags_list=(tags)
@tags_list = tags
end
def add_tag_to_list(tag)
tags_list << tag
end
def [](param)
super || parameter(param)
end
# Make sure this resource is equivalent to the provided Parser resource.
def merge_parser_resource(resource)
accumulate_benchmark("Individual resource merger", :attributes) { merge_attributes(resource) }
accumulate_benchmark("Individual resource merger", :parameters) { merge_parameters(resource) }
accumulate_benchmark("Individual resource merger", :tags) { merge_tags(resource) }
save()
end
def merge_attributes(resource)
args = self.class.rails_resource_initial_args(resource)
args.each do |param, value|
self[param] = value unless resource[param] == value
end
# Handle file specially
self.file = resource.file if (resource.file and (!resource.file or self.file != resource.file))
end
def merge_parameters(resource)
catalog_params = {}
resource.each do |param, value|
catalog_params[param.to_s] = value
end
db_params = {}
deletions = []
params_list.each do |value|
# First remove any parameters our catalog resource doesn't have at all.
deletions << value['id'] and next unless catalog_params.include?(value['name'])
# Now store them for later testing.
db_params[value['name']] ||= []
db_params[value['name']] << value
end
# Now get rid of any parameters whose value list is different.
# This might be extra work in cases where an array has added or lost
# a single value, but in the most common case (a single value has changed)
# this makes sense.
db_params.each do |name, value_hashes|
values = value_hashes.collect { |v| v['value'] }
value_hashes.each { |v| deletions << v['id'] } unless value_compare(catalog_params[name], values)
end
# Perform our deletions.
Puppet::Rails::ParamValue.delete(deletions) unless deletions.empty?
# Lastly, add any new parameters.
catalog_params.each do |name, value|
next if db_params.include?(name) && ! db_params[name].find{ |val| deletions.include?( val["id"] ) }
values = value.is_a?(Array) ? value : [value]
values.each do |v|
param_values.build(:value => serialize_value(v), :line => resource.line, :param_name => Puppet::Rails::ParamName.accumulate_by_name(name))
end
end
end
# Make sure the tag list is correct.
def merge_tags(resource)
in_db = []
deletions = []
resource_tags = resource.tags
tags_list.each do |tag|
deletions << tag['id'] and next unless resource_tags.include?(tag['name'])
in_db << tag['name']
end
Puppet::Rails::ResourceTag.delete(deletions) unless deletions.empty?
(resource_tags - in_db).each do |tag|
add_resource_tag(tag)
end
end
def value_compare(v,db_value)
v = [v] unless v.is_a?(Array)
v == db_value
end
def name
ref()
end
def parameter(param)
if pn = param_names.find_by_name(param)
return (pv = param_values.find(:first, :conditions => [ 'param_name_id = ?', pn])) ? pv.value : nil
end
end
def ref(dummy_argument=:work_arround_for_ruby_GC_bug)
"#{self[:restype].split("::").collect { |s| s.capitalize }.join("::")}[#{self.title}]"
end
# Returns a hash of parameter names and values, no ActiveRecord instances.
def to_hash
Puppet::Rails::ParamValue.find_all_params_from_resource(self).inject({}) do |hash, value|
hash[value['name']] ||= []
hash[value['name']] << value.value
hash
end
end
# Convert our object to a resource. Do not retain whether the object
# is exported, though, since that would cause it to get stripped
# from the configuration.
def to_resource(scope)
hash = self.attributes
hash["type"] = hash["restype"]
hash.delete("restype")
# FIXME At some point, we're going to want to retain this information
# for logging and auditing.
hash.delete("host_id")
hash.delete("updated_at")
hash.delete("source_file_id")
hash.delete("created_at")
hash.delete("id")
hash.each do |p, v|
hash.delete(p) if v.nil?
end
hash[:scope] = scope
hash[:source] = scope.source
hash[:params] = []
names = []
self.param_names.each do |pname|
# We can get the same name multiple times because of how the
# db layout works.
next if names.include?(pname.name)
names << pname.name
hash[:params] << pname.to_resourceparam(self, scope.source)
end
obj = Puppet::Parser::Resource.new(hash)
# Store the ID, so we can check if we're re-collecting the same resource.
obj.rails_id = self.id
obj
end
end
|