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
|
#!/usr/local/bin/ruby -w
# $Id$
# the available clients
require 'puppet'
require 'puppet/function'
require 'puppet/type'
#require 'puppet/fact'
require 'facter'
require 'puppet/transaction'
require 'puppet/transportable'
require 'puppet/metric'
$noclientnetworking = false
begin
require 'webrick'
require 'cgi'
require 'xmlrpc/client'
require 'xmlrpc/server'
rescue LoadError => detail
$noclientnetworking = detail
end
module Puppet
class NetworkClientError < RuntimeError; end
class ClientError < RuntimeError; end
#---------------------------------------------------------------
if $noclientnetworking
Puppet.err "Could not load client network libs: %s" % $noclientnetworking
else
class NetworkClient < XMLRPC::Client
@@methods = [ :getconfig ]
@@methods.each { |method|
self.send(:define_method,method) { |*args|
begin
call("puppetmaster.%s" % method.to_s,*args)
rescue => detail
raise NetworkClientError.new(detail)
end
}
}
def initialize(hash)
hash[:Path] ||= "/RPC2"
hash[:Server] ||= "localhost"
hash[:Port] ||= 8080
super(hash[:Server],hash[:Path],hash[:Port])
end
end
end
class Client
include Puppet
attr_accessor :local
def Client.facts
facts = {}
Facter.each { |name,fact|
facts[name] = fact.downcase
}
facts
end
def initialize(hash)
# to whom do we connect?
@server = nil
@nil = nil
if hash.include?(:Server)
case hash[:Server]
when String:
if $nonetworking
raise NetworkClientError.new("Networking not available: %s" %
$nonetworking)
end
args = {}
[:Port, :Server].each { |arg|
if hash.include?(:Port)
args[arg] = hash[arg]
end
}
@driver = Puppet::NetworkClient.new(args)
@local = false
when Puppet::Master:
@driver = hash[:Server]
@local = true
else
raise ClientError.new("Server must be a hostname or a " +
"Puppet::Master object")
end
else
raise ClientError.new("Must pass :Server to client")
end
end
def getconfig
#client.loadproperty('files/sslclient.properties')
Puppet.debug("getting config")
facts = Client.facts
unless facts.length > 0
raise Puppet::ClientError.new(
"Could not retrieve any facts"
)
end
objects = nil
if @local
objects = @driver.getconfig(facts)
else
textfacts = CGI.escape(Marshal::dump(facts))
textobjects = CGI.unescape(@driver.getconfig(textfacts))
begin
objects = Marshal::load(textobjects)
rescue => detail
raise Puppet::Error.new("Could not understand configuration")
end
end
if objects.is_a?(Puppet::TransBucket)
self.config(objects)
else
Puppet.warning objects.inspect
raise NetworkClientError.new(objects.class)
end
end
# this method is how the client receives the tree of Transportable
# objects
# for now, just descend into the tree and perform and necessary
# manipulations
def config(tree)
Puppet.debug("Calling config")
# XXX this is kind of a problem; if the user changes the state file
# after this, then we have to reload the file and everything...
begin
Puppet::Storage.init
Puppet::Storage.load
rescue => detail
Puppet.err "Corrupt state file %s" % Puppet[:statefile]
begin
File.unlink(Puppet[:statefile])
retry
rescue => detail
raise Puppet::Error.new("Cannot remove %s: %s" %
[Puppet[statefile], detail])
end
end
container = tree.to_type
#if @local
# container = tree.to_type
#else
# container = Marshal::load(tree).to_type
#end
# this is a gross hack... but i don't see a good way around it
# set all of the variables to empty
Puppet::Transaction.init
# for now we just evaluate the top-level container, but eventually
# there will be schedules and such associated with each object,
# and probably with the container itself
transaction = container.evaluate
#transaction = Puppet::Transaction.new(objects)
transaction.toplevel = true
transaction.evaluate
Puppet::Metric.gather
Puppet::Metric.tally
if Puppet[:rrdgraph] == true
Metric.store
Metric.graph
end
Puppet::Storage.store
#self.shutdown
end
#def callfunc(name,args)
# Puppet.debug("Calling callfunc on %s" % name)
# if function = Puppet::Function[name]
# #debug("calling function %s" % function)
# value = function.call(args)
# #debug("from %s got %s" % [name,value])
# return value
# else
# raise "Function '%s' not found" % name
# end
#end
private
#def on_init
# @default_namespace = 'urn:puppet-client'
# add_method(self, 'config', 'config')
# add_method(self, 'callfunc', 'name', 'arguments')
#end
def cert(filename)
OpenSSL::X509::Certificate.new(File.open(File.join(@dir, filename)) { |f|
f.read
})
end
def key(filename)
OpenSSL::PKey::RSA.new(File.open(File.join(@dir, filename)) { |f|
f.read
})
end
end
#---------------------------------------------------------------
end
|
