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
|
# Provides feature definitions.
module Puppet::Util::ProviderFeatures
# The class that models the features and handles checking whether the features
# are present.
class ProviderFeature
require 'puppet/util/methodhelper'
require 'puppet/util/docs'
require 'puppet/util'
include Puppet::Util
include Puppet::Util::MethodHelper
attr_accessor :name, :docs, :methods
# Are all of the requirements met?
def available?(obj)
if self.methods
if methods_available?(obj)
return true
else
return false
end
else
# In this case, the provider has to declare support for this
# feature, and that's been checked before we ever get to the
# method checks.
return false
end
end
def initialize(name, docs, hash)
self.name = symbolize(name)
self.docs = docs
hash = symbolize_options(hash)
set_options(hash)
end
private
# Are all of the required methods available?
def methods_available?(obj)
methods.each do |m|
if obj.is_a?(Class)
return false unless obj.public_method_defined?(m)
else
return false unless obj.respond_to?(m)
end
end
return true
end
end
# Define one or more features. At a minimum, features require a name
# and docs, and at this point they should also specify a list of methods
# required to determine if the feature is present.
def feature(name, docs, hash = {})
@features ||= {}
if @features.include?(name)
raise Puppet::DevError, "Feature %s is already defined" % name
end
begin
obj = ProviderFeature.new(name, docs, hash)
@features[obj.name] = obj
rescue ArgumentError => detail
error = ArgumentError.new(
"Could not create feature %s: %s" % [name, detail]
)
error.set_backtrace(detail.backtrace)
raise error
end
end
# Return a hash of all feature documentation.
def featuredocs
str = ""
@features ||= {}
return nil if @features.empty?
names = @features.keys.sort { |a,b| a.to_s <=> b.to_s }
names.each do |name|
doc = @features[name].docs.gsub(/\n\s+/, " ")
str += "- **%s**: %s\n" % [name, doc]
end
if providers.length > 0
headers = ["Provider", names].flatten
data = {}
providers.each do |provname|
data[provname] = []
prov = provider(provname)
names.each do |name|
if prov.feature?(name)
data[provname] << "**X**"
else
data[provname] << ""
end
end
end
str += doctable(headers, data)
end
str
end
# Generate a module that sets up the boolean methods to test for given
# features.
def feature_module
unless defined? @feature_module
@features ||= {}
@feature_module = ::Module.new
const_set("FeatureModule", @feature_module)
features = @features
# Create a feature? method that can be passed a feature name and
# determine if the feature is present.
@feature_module.send(:define_method, :feature?) do |name|
method = name.to_s + "?"
if respond_to?(method) and send(method)
return true
else
return false
end
end
# Create a method that will list all functional features.
@feature_module.send(:define_method, :features) do
return false unless defined?(features)
features.keys.find_all { |n| feature?(n) }.sort { |a,b|
a.to_s <=> b.to_s
}
end
# Create a boolean method for each feature so you can test them
# individually as you might need.
@features.each do |name, feature|
method = name.to_s + "?"
@feature_module.send(:define_method, method) do
if defined? @declared_features and @declared_features.include?(name)
true
elsif feature.available?(self)
true
else
false
end
end
end
# Allow the provider to declare that it has a given feature.
@feature_module.send(:define_method, :has_features) do |*names|
@declared_features ||= []
names.each do |name|
name = symbolize(name)
@declared_features << name
end
end
end
@feature_module
end
end
# $Id$
|
