| Path: | lib/mcollective/util.rb |
| Last Update: | Thu Apr 05 17:20:50 +0000 2012 |
| Path: | lib/mcollective/rpc.rb |
| Last Update: | Thu Apr 05 17:20:50 +0000 2012 |
| Path: | lib/mcollective/application.rb |
| Last Update: | Thu Apr 05 17:20:50 +0000 2012 |
| Path: | lib/mcollective/ssl.rb |
| Last Update: | Thu Apr 05 17:20:50 +0000 2012 |
| Path: | lib/mcollective/security.rb |
| Last Update: | Thu Apr 05 17:20:50 +0000 2012 |
| Path: | lib/mcollective/security/base.rb |
| Last Update: | Thu Apr 05 17:20:50 +0000 2012 |
| Path: | lib/mcollective/registration/base.rb |
| Last Update: | Thu Apr 05 17:20:50 +0000 2012 |
| Path: | lib/mcollective/pluginpackager/standard_definition.rb |
| Last Update: | Tue Apr 24 23:03:29 +0000 2012 |
| Path: | lib/mcollective/pluginpackager/agent_definition.rb |
| Last Update: | Tue Apr 24 23:03:29 +0000 2012 |
| Path: | lib/mcollective/facts/base.rb |
| Last Update: | Thu Apr 05 17:20:50 +0000 2012 |
| Path: | lib/mcollective/registration.rb |
| Last Update: | Thu Apr 05 17:20:50 +0000 2012 |
| Path: | lib/mcollective/client.rb |
| Last Update: | Thu Apr 05 17:20:50 +0000 2012 |
| Path: | lib/mcollective/rpc/agent.rb |
| Last Update: | Thu Apr 05 17:20:50 +0000 2012 |
| Path: | lib/mcollective/rpc/actionrunner.rb |
| Last Update: | Thu Apr 05 17:20:50 +0000 2012 |
| Path: | lib/mcollective/rpc/audit.rb |
| Last Update: | Thu Apr 05 17:20:50 +0000 2012 |
| Path: | lib/mcollective/rpc/progress.rb |
| Last Update: | Thu Apr 05 17:20:50 +0000 2012 |
| Path: | lib/mcollective/rpc/helpers.rb |
| Last Update: | Thu Apr 05 17:20:50 +0000 2012 |
| Path: | lib/mcollective/rpc/stats.rb |
| Last Update: | Thu Apr 05 17:20:50 +0000 2012 |
| Path: | lib/mcollective/rpc/client.rb |
| Last Update: | Mon Apr 30 17:34:07 +0000 2012 |
| Path: | lib/mcollective/rpc/request.rb |
| Last Update: | Thu Apr 05 17:20:50 +0000 2012 |
| Path: | lib/mcollective/rpc/ddl.rb |
| Last Update: | Thu Apr 05 17:20:50 +0000 2012 |
| Path: | lib/mcollective/rpc/reply.rb |
| Last Update: | Thu Apr 05 17:20:50 +0000 2012 |
| Path: | lib/mcollective/rpc/result.rb |
| Last Update: | Thu Apr 05 17:20:50 +0000 2012 |
| Path: | lib/mcollective/matcher/scanner.rb |
| Last Update: | Thu Apr 05 17:20:50 +0000 2012 |
| Path: | lib/mcollective/matcher/parser.rb |
| Last Update: | Thu Apr 05 17:20:50 +0000 2012 |
| Path: | lib/mcollective/shell.rb |
| Last Update: | Thu Apr 05 17:20:50 +0000 2012 |
| Path: | lib/mcollective/log.rb |
| Last Update: | Thu Apr 05 17:20:50 +0000 2012 |
| Path: | lib/mcollective/connector/base.rb |
| Last Update: | Thu Apr 05 17:20:50 +0000 2012 |
| Path: | lib/mcollective/runner.rb |
| Last Update: | Thu Apr 05 17:20:50 +0000 2012 |
| Path: | lib/mcollective/unix_daemon.rb |
| Last Update: | Thu Apr 05 17:20:50 +0000 2012 |
| Path: | lib/mcollective/pluginpackager.rb |
| Last Update: | Tue Apr 24 23:03:29 +0000 2012 |
| Path: | lib/mcollective/connector.rb |
| Last Update: | Thu Apr 05 17:20:50 +0000 2012 |
| Path: | lib/mcollective/applications.rb |
| Last Update: | Thu Apr 05 17:20:50 +0000 2012 |
| Path: | lib/mcollective/message.rb |
| Last Update: | Thu Apr 05 17:20:50 +0000 2012 |
| Path: | lib/mcollective/monkey_patches.rb |
| Last Update: | Thu Apr 05 17:20:50 +0000 2012 |
Make arrays of Symbols sortable
| RbConfig | = | ::Config |
| Path: | lib/mcollective/config.rb |
| Last Update: | Thu Apr 05 17:20:50 +0000 2012 |
| Path: | lib/mcollective/agents.rb |
| Last Update: | Thu Apr 05 17:20:50 +0000 2012 |
| Path: | lib/mcollective/windows_daemon.rb |
| Last Update: | Thu Apr 05 17:20:50 +0000 2012 |
| Path: | lib/mcollective/pluginmanager.rb |
| Last Update: | Thu Apr 05 17:20:50 +0000 2012 |
| Path: | lib/mcollective/facts.rb |
| Last Update: | Thu Apr 05 17:20:50 +0000 2012 |
| Path: | lib/mcollective/runnerstats.rb |
| Last Update: | Thu Apr 05 17:20:50 +0000 2012 |
| Path: | lib/mcollective/logger/syslog_logger.rb |
| Last Update: | Thu Apr 05 17:20:50 +0000 2012 |
| Path: | lib/mcollective/logger/base.rb |
| Last Update: | Thu Apr 05 17:20:50 +0000 2012 |
| Path: | lib/mcollective/logger/file_logger.rb |
| Last Update: | Thu Apr 05 17:20:50 +0000 2012 |
| Path: | lib/mcollective/logger/console_logger.rb |
| Last Update: | Thu Apr 05 17:20:50 +0000 2012 |
| Path: | lib/mcollective/logger.rb |
| Last Update: | Thu Apr 05 17:20:50 +0000 2012 |
| Path: | lib/mcollective/optionparser.rb |
| Last Update: | Thu Apr 05 17:20:50 +0000 2012 |
| Path: | lib/mcollective/matcher.rb |
| Last Update: | Thu Apr 05 17:20:50 +0000 2012 |
| Path: | lib/mcollective.rb |
| Last Update: | Tue Apr 24 23:03:29 +0000 2012 |
| Class | Symbol |
| In: |
lib/mcollective/monkey_patches.rb
|
| Parent: | Object |
Make arrays of Symbols sortable
| Class | Array |
| In: |
lib/mcollective/monkey_patches.rb
|
| Parent: | Object |
a method # that walks an array in groups, pass a block to call the block on each sub array
# File lib/mcollective/monkey_patches.rb, line 21
21: def in_groups_of(chunk_size, padded_with=nil, &block)
22: arr = self.clone
23:
24: # how many to add
25: padding = chunk_size - (arr.size % chunk_size)
26:
27: # pad at the end
28: arr.concat([padded_with] * padding) unless padding == chunk_size
29:
30: # how many chunks we'll make
31: count = arr.size / chunk_size
32:
33: # make that many arrays
34: result = []
35: count.times {|s| result << arr[s * chunk_size, chunk_size]}
36:
37: if block_given?
38: result.each_with_index do |a, i|
39: case block.arity
40: when 1
41: yield(a)
42: when 2
43: yield(a, (i == result.size - 1))
44: else
45: raise "Expected 1 or 2 arguments, got #{block.arity}"
46: end
47: end
48: else
49: result
50: end
51: end
| Class | MCollective::Optionparser |
| In: |
lib/mcollective/optionparser.rb
|
| Parent: | Object |
A simple helper to build cli tools that supports a uniform command line layout.
| parser | [R] |
Creates a new instance of the parser, you can supply defaults and include named groups of options.
Starts a parser that defaults to verbose and that includs the filter options:
oparser = MCollective::Optionparser.new({:verbose => true}, "filter")
Stats a parser in non verbose mode that does support discovery
oparser = MCollective::Optionparser.new()
Starts a parser in verbose mode that does not show the common options:
oparser = MCollective::Optionparser.new({:verbose => true}, "filter", "common")
# File lib/mcollective/optionparser.rb, line 20
20: def initialize(defaults = {}, include_sections = nil, exclude_sections = nil)
21: @parser = ::OptionParser.new
22:
23: @include = [include_sections].flatten
24: @exclude = [exclude_sections].flatten
25:
26: @options = Util.default_options
27:
28: @options.merge!(defaults)
29: end
These options will be added to most cli tools
# File lib/mcollective/optionparser.rb, line 128
128: def add_common_options
129: @parser.separator ""
130: @parser.separator "Common Options"
131:
132: @parser.on('-T', '--target COLLECTIVE', 'Target messages to a specific sub collective') do |f|
133: @options[:collective] = f
134: end
135:
136: @parser.on('--dt', '--discovery-timeout SECONDS', Integer, 'Timeout for doing discovery') do |t|
137: @options[:disctimeout] = t
138: end
139:
140: @parser.on('-t', '--timeout SECONDS', Integer, 'Timeout for calling remote agents') do |t|
141: @options[:timeout] = t
142: end
143:
144: @parser.on('-q', '--quiet', 'Do not be verbose') do |v|
145: @options[:verbose] = false
146: end
147:
148: @parser.on('--ttl TTL', 'Set the message validity period') do |v|
149: @options[:ttl] = v.to_i
150: end
151:
152: @parser.on('--reply-to TARGET', 'Set a custom target for replies') do |v|
153: @options[:reply_to] = v
154: end
155: end
These options will be added if you pass ‘filter’ into the include list of the constructor.
# File lib/mcollective/optionparser.rb, line 73
73: def add_filter_options
74: @parser.separator ""
75: @parser.separator "Host Filters"
76:
77: @parser.on('-W', '--with FILTER', 'Combined classes and facts filter') do |f|
78: f.split(" ").each do |filter|
79: begin
80: fact_parsed = parse_fact(filter)
81: @options[:filter]["fact"] << fact_parsed
82: rescue
83: @options[:filter]["cf_class"] << filter
84: end
85: end
86: end
87:
88: @parser.on('-S', '--select FILTER', 'Compound filter combining facts and classes') do |f|
89: @options[:filter]["compound"] << MCollective::Matcher::Parser.new(f).execution_stack
90: end
91:
92: @parser.on('-F', '--wf', '--with-fact fact=val', 'Match hosts with a certain fact') do |f|
93: fact_parsed = parse_fact(f)
94:
95: @options[:filter]["fact"] << fact_parsed if fact_parsed
96: end
97:
98: @parser.on('-C', '--wc', '--with-class CLASS', 'Match hosts with a certain config management class') do |f|
99: @options[:filter]["cf_class"] << f
100: end
101:
102: @parser.on('-A', '--wa', '--with-agent AGENT', 'Match hosts with a certain agent') do |a|
103: @options[:filter]["agent"] << a
104: end
105:
106: @parser.on('-I', '--wi', '--with-identity IDENT', 'Match hosts with a certain configured identity') do |a|
107: @options[:filter]["identity"] << a
108: end
109: end
These options should always be present
# File lib/mcollective/optionparser.rb, line 112
112: def add_required_options
113: @parser.on('-c', '--config FILE', 'Load configuratuion from file rather than default') do |f|
114: @options[:config] = f
115: end
116:
117: @parser.on('-v', '--verbose', 'Be verbose') do |v|
118: @options[:verbose] = v
119: end
120:
121: @parser.on('-h', '--help', 'Display this screen') do
122: puts @parser
123: exit! 1
124: end
125: end
Parse the options returning the options, you can pass a block that adds additional options to the Optionparser.
The sample below starts a parser that also prompts for —arguments in addition to the defaults. It also sets the description and shows a usage message specific to this app.
options = oparser.parse{|parser, options|
parser.define_head "Control the mcollective controller daemon"
parser.banner = "Usage: sh-mcollective [options] command"
parser.on('--arg', '--argument ARGUMENT', 'Argument to pass to agent') do |v|
options[:argument] = v
end
}
Users can set default options that get parsed in using the MCOLLECTIVE_EXTRA_OPTS environemnt variable
# File lib/mcollective/optionparser.rb, line 48
48: def parse(&block)
49: yield(@parser, @options) if block_given?
50:
51: add_required_options
52:
53: add_common_options unless @exclude.include?("common")
54:
55: @include.each do |i|
56: next if @exclude.include?(i)
57:
58: options_name = "add_#{i}_options"
59: send(options_name) if respond_to?(options_name)
60: end
61:
62: @parser.environment("MCOLLECTIVE_EXTRA_OPTS")
63:
64: @parser.parse!
65:
66: @options[:collective] = Config.instance.main_collective unless @options[:collective]
67:
68: @options
69: end
| Class | MCollective::WindowsDaemon |
| In: |
lib/mcollective/windows_daemon.rb
|
| Parent: | Win32::Daemon |
# File lib/mcollective/windows_daemon.rb, line 5
5: def self.daemonize_runner(pid=nil)
6: raise "Writing pid files are not supported on the Windows Platform" if pid
7: raise "The Windows Daemonizer should only be used on the Windows Platform" unless Util.windows?
8:
9: WindowsDaemon.mainloop
10: end
# File lib/mcollective/windows_daemon.rb, line 12
12: def service_main
13: Log.debug("Starting Windows Service Daemon")
14:
15: runner = Runner.new(nil)
16: runner.run
17: end
| Module | MCollective::Util |
| In: |
lib/mcollective/util.rb
|
Some basic utility helper methods useful to clients, agents, runner etc.
Picks a config file defaults to ~/.mcollective else /etc/mcollective/client.cfg
# File lib/mcollective/util.rb, line 140
140: def self.config_file_for_user
141: # expand_path is pretty lame, it relies on HOME environment
142: # which isnt't always there so just handling all exceptions
143: # here as cant find reverting to default
144: begin
145: config = File.expand_path("~/.mcollective")
146:
147: unless File.readable?(config) && File.file?(config)
148: config = "/etc/mcollective/client.cfg"
149: end
150: rescue Exception => e
151: config = "/etc/mcollective/client.cfg"
152: end
153:
154: return config
155: end
Creates a standard options hash
# File lib/mcollective/util.rb, line 158
158: def self.default_options
159: {:verbose => false,
160: :disctimeout => 2,
161: :timeout => 5,
162: :config => config_file_for_user,
163: :collective => nil,
164: :filter => empty_filter}
165: end
Creates an empty filter
# File lib/mcollective/util.rb, line 130
130: def self.empty_filter
131: {"fact" => [],
132: "cf_class" => [],
133: "agent" => [],
134: "identity" => [],
135: "compound" => []}
136: end
Checks if the passed in filter is an empty one
# File lib/mcollective/util.rb, line 125
125: def self.empty_filter?(filter)
126: filter == empty_filter || filter == {}
127: end
# File lib/mcollective/util.rb, line 250
250: def self.eval_compound_statement(expression)
251: if expression.values.first =~ /^\//
252: return Util.has_cf_class?(expression.values.first)
253: elsif expression.values.first =~ />=|<=|=|<|>/
254: optype = expression.values.first.match(/>=|<=|=|<|>/)
255: name, value = expression.values.first.split(optype[0])
256: unless value.split("")[0] == "/"
257: optype[0] == "=" ? optype = "==" : optype = optype[0]
258: else
259: optype = "=~"
260: end
261:
262: return Util.has_fact?(name,value, optype).to_s
263: else
264: return Util.has_cf_class?(expression.values.first)
265: end
266: end
Gets the value of a specific fact, mostly just a duplicate of MCollective::Facts.get_fact but it kind of goes with the other classes here
# File lib/mcollective/util.rb, line 61
61: def self.get_fact(fact)
62: Facts.get_fact(fact)
63: end
Finds out if this MCollective has an agent by the name passed
If the passed name starts with a / it‘s assumed to be regex and will use regex to match
# File lib/mcollective/util.rb, line 8
8: def self.has_agent?(agent)
9: agent = Regexp.new(agent.gsub("\/", "")) if agent.match("^/")
10:
11: if agent.is_a?(Regexp)
12: if Agents.agentlist.grep(agent).size > 0
13: return true
14: else
15: return false
16: end
17: else
18: return Agents.agentlist.include?(agent)
19: end
20:
21: false
22: end
Checks if this node has a configuration management class by parsing the a text file with just a list of classes, recipes, roles etc. This is ala the classes.txt from puppet.
If the passed name starts with a / it‘s assumed to be regex and will use regex to match
# File lib/mcollective/util.rb, line 38
38: def self.has_cf_class?(klass)
39: klass = Regexp.new(klass.gsub("\/", "")) if klass.match("^/")
40: cfile = Config.instance.classesfile
41:
42: Log.debug("Looking for configuration management classes in #{cfile}")
43:
44: begin
45: File.readlines(cfile).each do |k|
46: if klass.is_a?(Regexp)
47: return true if k.chomp.match(klass)
48: else
49: return true if k.chomp == klass
50: end
51: end
52: rescue Exception => e
53: Log.warn("Parsing classes file '#{cfile}' failed: #{e.class}: #{e}")
54: end
55:
56: false
57: end
Compares fact == value,
If the passed value starts with a / it‘s assumed to be regex and will use regex to match
# File lib/mcollective/util.rb, line 69
69: def self.has_fact?(fact, value, operator)
70:
71: Log.debug("Comparing #{fact} #{operator} #{value}")
72: Log.debug("where :fact = '#{fact}', :operator = '#{operator}', :value = '#{value}'")
73:
74: fact = Facts[fact]
75: return false if fact.nil?
76:
77: fact = fact.clone
78:
79: if operator == '=~'
80: # to maintain backward compat we send the value
81: # as /.../ which is what 1.0.x needed. this strips
82: # off the /'s wich is what we need here
83: if value =~ /^\/(.+)\/$/
84: value = $1
85: end
86:
87: return true if fact.match(Regexp.new(value))
88:
89: elsif operator == "=="
90: return true if fact == value
91:
92: elsif ['<=', '>=', '<', '>', '!='].include?(operator)
93: # Yuk - need to type cast, but to_i and to_f are overzealous
94: if value =~ /^[0-9]+$/ && fact =~ /^[0-9]+$/
95: fact = Integer(fact)
96: value = Integer(value)
97: elsif value =~ /^[0-9]+.[0-9]+$/ && fact =~ /^[0-9]+.[0-9]+$/
98: fact = Float(fact)
99: value = Float(value)
100: end
101:
102: return true if eval("fact #{operator} value")
103: end
104:
105: false
106: end
Checks if the configured identity matches the one supplied
If the passed name starts with a / it‘s assumed to be regex and will use regex to match
# File lib/mcollective/util.rb, line 112
112: def self.has_identity?(identity)
113: identity = Regexp.new(identity.gsub("\/", "")) if identity.match("^/")
114:
115: if identity.is_a?(Regexp)
116: return Config.instance.identity.match(identity)
117: else
118: return true if Config.instance.identity == identity
119: end
120:
121: false
122: end
Wrapper around PluginManager.loadclass
# File lib/mcollective/util.rb, line 206
206: def self.loadclass(klass)
207: PluginManager.loadclass(klass)
208: end
# File lib/mcollective/util.rb, line 167
167: def self.make_subscriptions(agent, type, collective=nil)
168: config = Config.instance
169:
170: raise("Unknown target type #{type}") unless [:broadcast, :directed, :reply].include?(type)
171:
172: if collective.nil?
173: config.collectives.map do |c|
174: {:agent => agent, :type => type, :collective => c}
175: end
176: else
177: raise("Unknown collective '#{collective}' known collectives are '#{config.collectives.join ', '}'") unless config.collectives.include?(collective)
178:
179: [{:agent => agent, :type => type, :collective => collective}]
180: end
181: end
Parse a fact filter string like foo=bar into the tuple hash thats needed
# File lib/mcollective/util.rb, line 211
211: def self.parse_fact_string(fact)
212: if fact =~ /^([^ ]+?)[ ]*=>[ ]*(.+)/
213: return {:fact => $1, :value => $2, :operator => '>=' }
214: elsif fact =~ /^([^ ]+?)[ ]*=<[ ]*(.+)/
215: return {:fact => $1, :value => $2, :operator => '<=' }
216: elsif fact =~ /^([^ ]+?)[ ]*(<=|>=|<|>|!=|==|=~)[ ]*(.+)/
217: return {:fact => $1, :value => $3, :operator => $2 }
218: elsif fact =~ /^(.+?)[ ]*=[ ]*\/(.+)\/$/
219: return {:fact => $1, :value => "/#{$2}/", :operator => '=~' }
220: elsif fact =~ /^([^= ]+?)[ ]*=[ ]*(.+)/
221: return {:fact => $1, :value => $2, :operator => '==' }
222: else
223: raise "Could not parse fact #{fact} it does not appear to be in a valid format"
224: end
225: end
Returns the current ruby version as per RUBY_VERSION, mostly doing this here to aid testing
# File lib/mcollective/util.rb, line 270
270: def self.ruby_version
271: RUBY_VERSION
272: end
On windows ^c can‘t interrupt the VM if its blocking on IO, so this sets up a dummy thread that sleeps and this will have the end result of being interruptable at least once a second. This is a common pattern found in Rails etc
# File lib/mcollective/util.rb, line 28
28: def self.setup_windows_sleeper
29: Thread.new { loop { sleep 1 } } if Util.windows?
30: end
Escapes a string so it‘s safe to use in system() or backticks
Taken from Shellwords#shellescape since it‘s only in a few ruby versions
# File lib/mcollective/util.rb, line 230
230: def self.shellescape(str)
231: return "''" if str.empty?
232:
233: str = str.dup
234:
235: # Process as a single byte sequence because not all shell
236: # implementations are multibyte aware.
237: str.gsub!(/([^A-Za-z0-9_\-.,:\/@\n])/n, "\\\\\\1")
238:
239: # A LF cannot be escaped with a backslash because a backslash + LF
240: # combo is regarded as line continuation and simply ignored.
241: str.gsub!(/\n/, "'\n'")
242:
243: return str
244: end
Helper to subscribe to a topic on multiple collectives or just one
# File lib/mcollective/util.rb, line 184
184: def self.subscribe(targets)
185: connection = PluginManager["connector_plugin"]
186:
187: targets = [targets].flatten
188:
189: targets.each do |target|
190: connection.subscribe(target[:agent], target[:type], target[:collective])
191: end
192: end
Helper to unsubscribe to a topic on multiple collectives or just one
# File lib/mcollective/util.rb, line 195
195: def self.unsubscribe(targets)
196: connection = PluginManager["connector_plugin"]
197:
198: targets = [targets].flatten
199:
200: targets.each do |target|
201: connection.unsubscribe(target[:agent], target[:type], target[:collective])
202: end
203: end
| Class | MCollective::Matcher::Parser |
| In: |
lib/mcollective/matcher/parser.rb
|
| Parent: | Object |
| execution_stack | [R] | |
| scanner | [R] |
# File lib/mcollective/matcher/parser.rb, line 6
6: def initialize(args)
7: @scanner = Scanner.new(args)
8: @execution_stack = []
9: parse
10: end
Parse the input string, one token at a time a contruct the call stack
# File lib/mcollective/matcher/parser.rb, line 13
13: def parse
14: p_token,p_token_value = nil
15: c_token,c_token_value = @scanner.get_token
16: parenth = 0
17:
18: while (c_token != nil)
19: @scanner.token_index += 1
20: n_token, n_token_value = @scanner.get_token
21:
22: unless n_token == " "
23: case c_token
24: when "and"
25: unless (n_token =~ /not|statement|\(/) || (scanner.token_index == scanner.arguments.size)
26: raise "Error at column #{scanner.token_index}. \nExpected 'not', 'statement' or '('. Found '#{n_token_value}'"
27: end
28:
29: if p_token == nil
30: raise "Error at column #{scanner.token_index}. \n Expression cannot start with 'and'"
31: elsif (p_token == "and" || p_token == "or")
32: raise "Error at column #{scanner.token_index}. \n #{p_token} cannot be followed by 'and'"
33: end
34:
35: when "or"
36: unless (n_token =~ /not|statement|\(/) || (scanner.token_index == scanner.arguments.size)
37: raise "Error at column #{scanner.token_index}. \nExpected 'not', 'statement', '('. Found '#{n_token_value}'"
38: end
39:
40: if p_token == nil
41: raise "Error at column #{scanner.token_index}. \n Expression cannot start with 'or'"
42: elsif (p_token == "and" || p_token == "or")
43: raise "Error at column #{scanner.token_index}. \n #{p_token} cannot be followed by 'or'"
44: end
45:
46: when "not"
47: unless n_token =~ /statement|\(|not/
48: raise "Error at column #{scanner.token_index}. \nExpected 'statement' or '('. Found '#{n_token_value}'"
49: end
50:
51: when "statement"
52: unless n_token =~ /and|or|\)/
53: unless scanner.token_index == scanner.arguments.size
54: raise "Error at column #{scanner.token_index}. \nExpected 'and', 'or', ')'. Found '#{n_token_value}'"
55: end
56: end
57:
58: when ")"
59: unless (n_token =~ /|and|or|not|\(/)
60: unless(scanner.token_index == scanner.arguments.size)
61: raise "Error at column #{scanner.token_index}. \nExpected 'and', 'or', 'not' or '('. Found '#{n_token_value}'"
62: end
63: end
64: parenth += 1
65:
66: when "("
67: unless n_token =~ /statement|not|\(/
68: raise "Error at column #{scanner.token_index}. \nExpected 'statement', '(', not. Found '#{n_token_value}'"
69: end
70: parenth -= 1
71:
72: else
73: raise "Unexpected token found at column #{scanner.token_index}. '#{c_token_value}'"
74: end
75:
76: unless n_token == " "
77: @execution_stack << {c_token => c_token_value}
78: end
79:
80: p_token, p_token_value = c_token, c_token_value
81: c_token, c_token_value = n_token, n_token_value
82: end
83: end
84:
85: if parenth < 0
86: raise "Error. Missing parentheses ')'."
87: elsif parenth > 0
88: raise "Error. Missing parentheses '('."
89: end
90: end
| Class | MCollective::Matcher::Scanner |
| In: |
lib/mcollective/matcher/scanner.rb
|
| Parent: | Object |
| arguments | [RW] | |
| token_index | [RW] |
# File lib/mcollective/matcher/scanner.rb, line 6 6: def initialize(arguments) 7: @token_index = 0 8: @arguments = arguments 9: end
Scans the input string and identifies single language tokens
# File lib/mcollective/matcher/scanner.rb, line 12
12: def get_token
13: if @token_index >= @arguments.size
14: return nil
15: end
16:
17: begin
18: case @arguments.split("")[@token_index]
19: when "("
20: return "(", "("
21:
22: when ")"
23: return ")", ")"
24:
25: when "n"
26: if (@arguments.split("")[@token_index + 1] == "o") && (@arguments.split("")[@token_index + 2] == "t") && ((@arguments.split("")[@token_index + 3] == " ") || (@arguments.split("")[@token_index + 3] == "("))
27: @token_index += 2
28: return "not", "not"
29: else
30: gen_statement
31: end
32:
33: when "!"
34: return "not", "not"
35:
36: when "a"
37: if (@arguments.split("")[@token_index + 1] == "n") && (@arguments.split("")[@token_index + 2] == "d") && ((@arguments.split("")[@token_index + 3] == " ") || (@arguments.split("")[@token_index + 3] == "("))
38: @token_index += 2
39: return "and", "and"
40: else
41: gen_statement
42: end
43:
44: when "o"
45: if (@arguments.split("")[@token_index + 1] == "r") && ((@arguments.split("")[@token_index + 2] == " ") || (@arguments.split("")[@token_index + 2] == "("))
46: @token_index += 1
47: return "or", "or"
48: else
49: gen_statement
50: end
51:
52: when " "
53: return " ", " "
54:
55: else
56: gen_statement
57: end
58: end
59: rescue NoMethodError => e
60: pp e
61: raise "Cannot end statement with 'and', 'or', 'not'"
62: end
| Module | MCollective::PluginManager |
| In: |
lib/mcollective/pluginmanager.rb
|
A simple plugin manager, it stores one plugin each of a specific type the idea is that we can only have one security provider, one connector etc.
Adds a plugin to the list of plugins, we expect a hash like:
{:type => "base",
:class => foo.new}
or like:
{:type => "base",
:class => "Foo::Bar"}
In the event that we already have a class with the given type an exception will be raised.
If the :class passed is a String then we will delay instantiation till the first time someone asks for the plugin, this is because most likely the registration gets done by inherited() hooks, at which point the plugin class is not final.
If we were to do a .new here the Class initialize method would get called and not the plugins, we there for only initialize the classes when they get requested via []
By default all plugin instances are cached and returned later so there‘s always a single instance. You can pass :single_instance => false when calling this to instruct it to always return a new instance when a copy is requested. This only works with sending a String for :class.
# File lib/mcollective/pluginmanager.rb, line 30
30: def self.<<(plugin)
31: plugin[:single_instance] = true unless plugin.include?(:single_instance)
32:
33: type = plugin[:type]
34: klass = plugin[:class]
35: single = plugin[:single_instance]
36:
37: raise("Plugin #{type} already loaded") if @plugins.include?(type)
38:
39:
40: # If we get a string then store 'nil' as the instance, signalling that we'll
41: # create the class later on demand.
42: if klass.is_a?(String)
43: @plugins[type] = {:loadtime => Time.now, :class => klass, :instance => nil, :single => single}
44: Log.debug("Registering plugin #{type} with class #{klass} single_instance: #{single}")
45: else
46: @plugins[type] = {:loadtime => Time.now, :class => klass.class, :instance => klass, :single => true}
47: Log.debug("Registering plugin #{type} with class #{klass.class} single_instance: true")
48: end
49: end
Gets a plugin by type
# File lib/mcollective/pluginmanager.rb, line 72
72: def self.[](plugin)
73: raise("No plugin #{plugin} defined") unless @plugins.include?(plugin)
74:
75: klass = @plugins[plugin][:class]
76:
77: if @plugins[plugin][:single]
78: # Create an instance of the class if one hasn't been done before
79: if @plugins[plugin][:instance] == nil
80: Log.debug("Returning new plugin #{plugin} with class #{klass}")
81: @plugins[plugin][:instance] = create_instance(klass)
82: else
83: Log.debug("Returning cached plugin #{plugin} with class #{klass}")
84: end
85:
86: @plugins[plugin][:instance]
87: else
88: Log.debug("Returning new plugin #{plugin} with class #{klass}")
89: create_instance(klass)
90: end
91: end
deletes all registered plugins
# File lib/mcollective/pluginmanager.rb, line 67
67: def self.clear
68: @plugins.clear
69: end
use eval to create an instance of a class
# File lib/mcollective/pluginmanager.rb, line 94
94: def self.create_instance(klass)
95: begin
96: eval("#{klass}.new")
97: rescue Exception => e
98: raise("Could not create instance of plugin #{klass}: #{e}")
99: end
100: end
Removes a plugim the list
# File lib/mcollective/pluginmanager.rb, line 52
52: def self.delete(plugin)
53: @plugins.delete(plugin) if @plugins.include?(plugin)
54: end
Finds plugins in all configured libdirs
find("agent")
will return an array of just agent names, for example:
["puppetd", "package"]
Can also be used to find files of other extensions:
find("agent", "ddl")
Will return the same list but only of files with extension .ddl in the agent subdirectory
# File lib/mcollective/pluginmanager.rb, line 116
116: def self.find(type, extension="rb")
117: extension = ".#{extension}" unless extension.match(/^\./)
118:
119: plugins = []
120:
121: Config.instance.libdir.each do |libdir|
122: plugdir = File.join([libdir, "mcollective", type])
123: next unless File.directory?(plugdir)
124:
125: Dir.new(plugdir).grep(/#{extension}$/).map do |plugin|
126: plugins << File.basename(plugin, extension)
127: end
128: end
129:
130: plugins.sort.uniq
131: end
Finds and loads from disk all plugins from all libdirs that match certain criteria.
find_and_load("pluginpackager")
Will find all .rb files in the libdir/mcollective/pluginpackager/ directory in all libdirs and load them from disk.
You can influence what plugins get loaded using a block notation:
find_and_load("pluginpackager") do |plugin|
plugin.match(/puppet/)
end
This will load only plugins matching /puppet/
# File lib/mcollective/pluginmanager.rb, line 148
148: def self.find_and_load(type, extension="rb")
149: extension = ".#{extension}" unless extension.match(/^\./)
150:
151: klasses = find(type, extension).map do |plugin|
152: if block_given?
153: next unless yield(plugin)
154: end
155:
156: "%s::%s::%s" % [ "MCollective", type.capitalize, plugin.capitalize ]
157: end.compact
158:
159: klasses.sort.uniq.each {|klass| loadclass(klass, true)}
160: end
Grep‘s over the plugin list and returns the list found
# File lib/mcollective/pluginmanager.rb, line 176
176: def self.grep(regex)
177: @plugins.keys.grep regex
178: end
Finds out if we have a plugin with the given name
# File lib/mcollective/pluginmanager.rb, line 57
57: def self.include?(plugin)
58: @plugins.include?(plugin)
59: end
Loads a class from file by doing some simple search/replace on class names and then doing a require.
# File lib/mcollective/pluginmanager.rb, line 164
164: def self.loadclass(klass, squash_failures=false)
165: fname = klass.gsub("::", "/").downcase + ".rb"
166:
167: Log.debug("Loading #{klass} from #{fname}")
168:
169: load fname
170: rescue Exception => e
171: Log.error("Failed to load #{klass}: #{e}")
172: raise unless squash_failures
173: end
| Class | MCollective::Agents |
| In: |
lib/mcollective/agents.rb
|
| Parent: | Object |
A collection of agents, loads them, reloads them and dispatches messages to them. It uses the PluginManager to store, load and manage instances of plugins.
Get a list of agents that we have
# File lib/mcollective/agents.rb, line 156
156: def self.agentlist
157: @@agents.keys
158: end
# File lib/mcollective/agents.rb, line 5
5: def initialize(agents = {})
6: @config = Config.instance
7: raise ("Configuration has not been loaded, can't load agents") unless @config.configured
8:
9: @@agents = agents
10:
11: loadagents
12: end
Checks if a plugin should be activated by calling activate? on it if it responds to that method else always activate it
# File lib/mcollective/agents.rb, line 80
80: def activate_agent?(agent)
81: klass = Kernel.const_get("MCollective").const_get("Agent").const_get(agent.capitalize)
82:
83: if klass.respond_to?("activate?")
84: return klass.activate?
85: else
86: Log.debug("#{klass} does not have an activate? method, activating as default")
87: return true
88: end
89: rescue Exception => e
90: Log.warn("Agent activation check for #{agent} failed: #{e.class}: #{e}")
91: return false
92: end
Builds a class name string given a Agent name
# File lib/mcollective/agents.rb, line 73
73: def class_for_agent(agent)
74: "MCollective::Agent::#{agent.capitalize}"
75: end
Deletes all agents
# File lib/mcollective/agents.rb, line 15
15: def clear!
16: @@agents.each_key do |agent|
17: PluginManager.delete "#{agent}_agent"
18: Util.unsubscribe(Util.make_subscriptions(agent, :broadcast))
19: end
20:
21: @@agents = {}
22: end
Dispatches a message to an agent, accepts a block that will get run if there are any replies to process from the agent
# File lib/mcollective/agents.rb, line 129
129: def dispatch(request, connection)
130: Log.debug("Dispatching a message to agent #{request.agent}")
131:
132: Thread.new do
133: begin
134: agent = PluginManager["#{request.agent}_agent"]
135:
136: Timeout::timeout(agent.timeout) do
137: replies = agent.handlemsg(request.payload, connection)
138:
139: # Agents can decide if they wish to reply or not,
140: # returning nil will mean nothing goes back to the
141: # requestor
142: unless replies == nil
143: yield(replies)
144: end
145: end
146: rescue Timeout::Error => e
147: Log.warn("Timeout while handling message for #{request.agent}")
148: rescue Exception => e
149: Log.error("Execution of #{request.agent} failed: #{e}")
150: Log.error(e.backtrace.join("\n\t\t"))
151: end
152: end
153: end
searches the libdirs for agents
# File lib/mcollective/agents.rb, line 95
95: def findagentfile(agentname)
96: @config.libdir.each do |libdir|
97: agentfile = File.join([libdir, "mcollective", "agent", "#{agentname}.rb"])
98: if File.exist?(agentfile)
99: Log.debug("Found #{agentname} at #{agentfile}")
100: return agentfile
101: end
102: end
103: return false
104: end
Returns the help for an agent after first trying to get rid of some indentation infront
# File lib/mcollective/agents.rb, line 113
113: def help(agentname)
114: raise("No such agent") unless include?(agentname)
115:
116: body = PluginManager["#{agentname}_agent"].help.split("\n")
117:
118: if body.first =~ /^(\s+)\S/
119: indent = $1
120:
121: body = body.map {|b| b.gsub(/^#{indent}/, "")}
122: end
123:
124: body.join("\n")
125: end
Determines if we have an agent with a certain name
# File lib/mcollective/agents.rb, line 107
107: def include?(agentname)
108: PluginManager.include?("#{agentname}_agent")
109: end
Loads a specified agent from disk if available
# File lib/mcollective/agents.rb, line 42
42: def loadagent(agentname)
43: agentfile = findagentfile(agentname)
44: return false unless agentfile
45: classname = class_for_agent(agentname)
46:
47: PluginManager.delete("#{agentname}_agent")
48:
49: begin
50: single_instance = ["registration", "discovery"].include?(agentname)
51:
52: PluginManager.loadclass(classname)
53:
54: if activate_agent?(agentname)
55: PluginManager << {:type => "#{agentname}_agent", :class => classname, :single_instance => single_instance}
56:
57: Util.subscribe(Util.make_subscriptions(agentname, :broadcast)) unless @@agents.include?(agentname)
58:
59: @@agents[agentname] = {:file => agentfile}
60: return true
61: else
62: Log.debug("Not activating agent #{agentname} due to agent policy in activate? method")
63: return false
64: end
65: rescue Exception => e
66: Log.error("Loading agent #{agentname} failed: #{e}")
67: PluginManager.delete("#{agentname}_agent")
68: return false
69: end
70: end
Loads all agents from disk
# File lib/mcollective/agents.rb, line 25
25: def loadagents
26: Log.debug("Reloading all agents from disk")
27:
28: clear!
29:
30: @config.libdir.each do |libdir|
31: agentdir = "#{libdir}/mcollective/agent"
32: next unless File.directory?(agentdir)
33:
34: Dir.new(agentdir).grep(/\.rb$/).each do |agent|
35: agentname = File.basename(agent, ".rb")
36: loadagent(agentname) unless PluginManager.include?("#{agentname}_agent")
37: end
38: end
39: end
| Class | MCollective::SecurityValidationFailed |
| In: |
lib/mcollective.rb
|
| Parent: | RuntimeError |
| Module | MCollective::Connector |
| In: |
lib/mcollective/connector/base.rb
lib/mcollective/connector.rb |
Connectors take care of transporting messages between clients and agents, the design doesn‘t your middleware to be very rich in features. All it really needs is the ability to send and receive messages to named queues/topics.
At present there are assumptions about the naming of topics and queues that is compatible with Stomp, ie.
/topic/foo.bar/baz /queue/foo.bar/baz
This is the only naming format that is supported, but you could replace Stomp with something else that supports the above, see MCollective::Connector::Stomp for the default connector.
| Class | MCollective::Config |
| In: |
lib/mcollective/config.rb
|
| Parent: | Object |
A pretty sucky config class, ripe for refactoring/improving
| classesfile | [R] | |
| collectives | [R] | |
| color | [R] | |
| configdir | [R] | |
| configfile | [R] | |
| configured | [R] | |
| connector | [R] | |
| daemonize | [R] | |
| daemonize | [R] | |
| direct_addressing | [R] | |
| direct_addressing_threshold | [R] | |
| fact_cache_time | [R] | |
| factsource | [R] | |
| identity | [R] | |
| keeplogs | [R] | |
| libdir | [R] | |
| logfacility | [R] | |
| logfile | [R] | |
| logger_type | [R] | |
| loglevel | [R] | |
| main_collective | [R] | |
| max_log_size | [R] | |
| pluginconf | [R] | |
| queueprefix | [R] | |
| registerinterval | [R] | |
| registration | [R] | |
| registration_collective | [R] | |
| rpcaudit | [R] | |
| rpcauditprovider | [R] | |
| rpcauthorization | [R] | |
| rpcauthprovider | [R] | |
| rpchelptemplate | [R] | |
| rpclimitmethod | [R] | |
| securityprovider | [R] | |
| ssl_cipher | [R] | |
| topicprefix | [R] | |
| topicsep | [R] | |
| ttl | [R] |
# File lib/mcollective/config.rb, line 19
19: def loadconfig(configfile)
20: set_config_defaults(configfile)
21:
22: if File.exists?(configfile)
23: File.open(configfile, "r").each do |line|
24:
25: # strip blank spaces, tabs etc off the end of all lines
26: line.gsub!(/\s*$/, "")
27:
28: unless line =~ /^#|^$/
29: if (line =~ /(.+?)\s*=\s*(.+)/)
30: key = $1
31: val = $2
32:
33: case key
34: when "topicsep"
35: @topicsep = val
36: when "registration"
37: @registration = val.capitalize
38: when "registration_collective"
39: @registration_collective = val
40: when "registerinterval"
41: @registerinterval = val.to_i
42: when "collectives"
43: @collectives = val.split(",").map {|c| c.strip}
44: when "main_collective"
45: @main_collective = val
46: when "topicprefix"
47: @topicprefix = val
48: when "queueprefix"
49: @queueprefix = val
50: when "logfile"
51: @logfile = val
52: when "keeplogs"
53: @keeplogs = val.to_i
54: when "max_log_size"
55: @max_log_size = val.to_i
56: when "loglevel"
57: @loglevel = val
58: when "logfacility"
59: @logfacility = val
60: when "libdir"
61: paths = val.split(File::PATH_SEPARATOR)
62: paths.each do |path|
63: @libdir << path
64: unless $LOAD_PATH.include?(path)
65: $LOAD_PATH << path
66: end
67: end
68: when "identity"
69: @identity = val
70: when "direct_addressing"
71: val =~ /^1|y/i ? @direct_addressing = true : @direct_addressing = false
72: when "direct_addressing_threshold"
73: @direct_addressing_threshold = val.to_i
74: when "color"
75: val =~ /^1|y/i ? @color = true : @color = false
76: when "daemonize"
77: val =~ /^1|y/i ? @daemonize = true : @daemonize = false
78: when "securityprovider"
79: @securityprovider = val.capitalize
80: when "factsource"
81: @factsource = val.capitalize
82: when "connector"
83: @connector = val.capitalize
84: when "classesfile"
85: @classesfile = val
86: when /^plugin.(.+)$/
87: @pluginconf[$1] = val
88: when "rpcaudit"
89: val =~ /^1|y/i ? @rpcaudit = true : @rpcaudit = false
90: when "rpcauditprovider"
91: @rpcauditprovider = val.capitalize
92: when "rpcauthorization"
93: val =~ /^1|y/i ? @rpcauthorization = true : @rpcauthorization = false
94: when "rpcauthprovider"
95: @rpcauthprovider = val.capitalize
96: when "rpchelptemplate"
97: @rpchelptemplate = val
98: when "rpclimitmethod"
99: @rpclimitmethod = val.to_sym
100: when "logger_type"
101: @logger_type = val
102: when "fact_cache_time"
103: @fact_cache_time = val.to_i
104: when "ssl_cipher"
105: @ssl_cipher = val
106: when "ttl"
107: @ttl = val.to_i
108: else
109: raise("Unknown config parameter #{key}")
110: end
111: end
112: end
113: end
114:
115: read_plugin_config_dir("#{@configdir}/plugin.d")
116:
117: raise 'Identities can only match /\w\.\-/' unless @identity.match(/^[\w\.\-]+$/)
118:
119: @configured = true
120:
121: @libdir.each {|dir| Log.warn("Cannot find libdir: #{dir}") unless File.directory?(dir)}
122:
123: if @logger_type == "syslog"
124: raise "The sylog logger is not usable on the Windows platform" if Util.windows?
125: end
126:
127: PluginManager.loadclass("Mcollective::Facts::#{@factsource}_facts")
128: PluginManager.loadclass("Mcollective::Connector::#{@connector}")
129: PluginManager.loadclass("Mcollective::Security::#{@securityprovider}")
130: PluginManager.loadclass("Mcollective::Registration::#{@registration}")
131: PluginManager.loadclass("Mcollective::Audit::#{@rpcauditprovider}") if @rpcaudit
132: PluginManager << {:type => "global_stats", :class => RunnerStats.new}
133: else
134: raise("Cannot find config file '#{configfile}'")
135: end
136: end
# File lib/mcollective/config.rb, line 182
182: def read_plugin_config_dir(dir)
183: return unless File.directory?(dir)
184:
185: Dir.new(dir).each do |pluginconfigfile|
186: next unless pluginconfigfile =~ /^([\w]+).cfg$/
187:
188: plugin = $1
189: File.open("#{dir}/#{pluginconfigfile}", "r").each do |line|
190: # strip blank lines
191: line.gsub!(/\s*$/, "")
192: next if line =~ /^#|^$/
193: if (line =~ /(.+?)\s*=\s*(.+)/)
194: key = $1
195: val = $2
196: @pluginconf["#{plugin}.#{key}"] = val
197: end
198: end
199: end
200: end
# File lib/mcollective/config.rb, line 138
138: def set_config_defaults(configfile)
139: @stomp = Hash.new
140: @subscribe = Array.new
141: @pluginconf = Hash.new
142: @connector = "Stomp"
143: @securityprovider = "Psk"
144: @factsource = "Yaml"
145: @identity = Socket.gethostname
146: @registration = "Agentlist"
147: @registerinterval = 0
148: @registration_collective = nil
149: @topicsep = "."
150: @topicprefix = "/topic/"
151: @queueprefix = "/queue/"
152: @classesfile = "/var/lib/puppet/state/classes.txt"
153: @rpcaudit = false
154: @rpcauditprovider = ""
155: @rpcauthorization = false
156: @rpcauthprovider = ""
157: @configdir = File.dirname(configfile)
158: @color = !Util.windows?
159: @configfile = configfile
160: @logger_type = "file"
161: @keeplogs = 5
162: @max_log_size = 2097152
163: @rpclimitmethod = :first
164: @libdir = Array.new
165: @fact_cache_time = 300
166: @loglevel = "info"
167: @logfacility = "user"
168: @collectives = ["mcollective"]
169: @main_collective = @collectives.first
170: @ssl_cipher = "aes-256-cbc"
171: @direct_addressing = false
172: @direct_addressing_threshold = 10
173: @ttl = 60
174:
175: # look in the config dir for the template so users can provide their own and windows
176: # with odd paths will just work more often, but fall back to old behavior if it does
177: # not exist
178: @rpchelptemplate = File.join(File.dirname(configfile), "rpc-help.erb")
179: @rpchelptemplate = "/etc/mcollective/rpc-help.erb" unless File.exists?(@rpchelptemplate)
180: end
| Class | MCollective::UnixDaemon |
| In: |
lib/mcollective/unix_daemon.rb
|
| Parent: | Object |
Daemonize the current process
# File lib/mcollective/unix_daemon.rb, line 4
4: def self.daemonize
5: fork do
6: Process.setsid
7: exit if fork
8: Dir.chdir('/tmp')
9: STDIN.reopen('/dev/null')
10: STDOUT.reopen('/dev/null', 'a')
11: STDERR.reopen('/dev/null', 'a')
12:
13: yield
14: end
15: end
# File lib/mcollective/unix_daemon.rb, line 17
17: def self.daemonize_runner(pid=nil)
18: raise "The Unix Daemonizer can not be used on the Windows Platform" if Util.windows?
19:
20: UnixDaemon.daemonize do
21: if pid
22: begin
23: File.open(pid, 'w') {|f| f.write(Process.pid) }
24: rescue Exception => e
25: end
26: end
27:
28: begin
29: runner = Runner.new(nil)
30: runner.run
31: ensure
32: File.unlink(pid) if pid && File.exist?(pid)
33: end
34: end
35: end
| Class | MCollective::NotTargettedAtUs |
| In: |
lib/mcollective.rb
|
| Parent: | RuntimeError |
| Class | MCollective::RunnerStats |
| In: |
lib/mcollective/runnerstats.rb
|
| Parent: | Object |
Class to store stats about the mcollectived, it should live in the PluginManager so that agents etc can get hold of it and return the stats to callers
# File lib/mcollective/runnerstats.rb, line 5
5: def initialize
6: @starttime = Time.now.to_i
7: @validated = 0
8: @unvalidated = 0
9: @filtered = 0
10: @passed = 0
11: @total = 0
12: @replies = 0
13: @ttlexpired = 0
14:
15: @mutex = Mutex.new
16: end
Records a message that didnt pass the filters
# File lib/mcollective/runnerstats.rb, line 31
31: def filtered
32: Log.debug("Incrementing filtered stat")
33: @filtered += 1
34: end
Records receipt of a message
# File lib/mcollective/runnerstats.rb, line 48
48: def received
49: Log.debug("Incrementing total stat")
50: @total += 1
51: end
Records sending a message
# File lib/mcollective/runnerstats.rb, line 54
54: def sent
55: @mutex.synchronize do
56: Log.debug("Incrementing replies stat")
57: @replies += 1
58: end
59: end
Returns a hash with all stats
# File lib/mcollective/runnerstats.rb, line 62
62: def to_hash
63: stats = {:validated => @validated,
64: :unvalidated => @unvalidated,
65: :passed => @passed,
66: :filtered => @filtered,
67: :starttime => @starttime,
68: :total => @total,
69: :ttlexpired => @ttlexpired,
70: :replies => @replies}
71:
72: reply = {:stats => stats,
73: :threads => [],
74: :pid => Process.pid,
75: :times => {} }
76:
77: ::Process.times.each_pair{|k,v|
78: k = k.to_sym
79: reply[:times][k] = v
80: }
81:
82: Thread.list.each do |t|
83: reply[:threads] << "#{t.inspect}"
84: end
85:
86: reply[:agents] = Agents.agentlist
87: reply
88: end
Records a message that failed TTL checks
# File lib/mcollective/runnerstats.rb, line 19
19: def ttlexpired
20: Log.debug("Incrementing ttl expired stat")
21: @ttlexpired += 1
22: end
# File lib/mcollective/runnerstats.rb, line 42
42: def unvalidated
43: Log.debug("Incrementing unvalidated stat")
44: @unvalidated += 1
45: end
| Class | MCollective::MsgTTLExpired |
| In: |
lib/mcollective.rb
|
| Parent: | RuntimeError |
Toolset to create a standard interface of client and agent using an RPC metaphor, standard compliant agents will make it easier to create generic clients like web interfaces etc
means for other classes to drop discovered hosts into this module its a bit hacky but needed so that the mixin methods like printrpcstats can easily get access to it without users having to pass it around in params.
# File lib/mcollective/rpc.rb, line 108
108: def self.discovered(discovered)
109: @@discovered = discovered
110: end
Factory for RPC::Reply messages, only really here to make agents a bit easier to understand
# File lib/mcollective/rpc.rb, line 184
184: def self.reply
185: RPC::Reply.new
186: end
Factory for RPC::Request messages, only really here to make agents a bit easier to understand
# File lib/mcollective/rpc.rb, line 178
178: def self.request(msg)
179: RPC::Request.new(msg)
180: end
means for other classes to drop stats into this module its a bit hacky but needed so that the mixin methods like printrpcstats can easily get access to it without users having to pass it around in params.
# File lib/mcollective/rpc.rb, line 100
100: def self.stats(stats)
101: @@stats = stats
102: end
Wrapper for MCollective::Util.empty_filter? to make clients less fugly to write - ticket 18
# File lib/mcollective/rpc.rb, line 168
168: def empty_filter?(options)
169: if options.include?(:filter)
170: Util.empty_filter?(options[:filter])
171: else
172: Util.empty_filter?(options)
173: end
174: end
Prints the result of an RPC call.
In the default quiet mode - no flattening or verbose - only results that produce an error will be printed
To get details of each result run with the -v command line option.
# File lib/mcollective/rpc.rb, line 148
148: def printrpc(result, flags = {})
149: verbose = @options[:verbose] rescue verbose = false
150: verbose = flags[:verbose] || verbose
151: flatten = flags[:flatten] || false
152: format = @options[:output_format]
153:
154: result_text = Helpers.rpcresults(result, {:verbose => verbose, :flatten => flatten, :format => format})
155:
156: if result.is_a?(Array) && format == :console
157: puts "\n%s\n" % [ result_text ]
158: else
159: # when we get just one result to print dont pad them all with
160: # blank spaces etc, just print the individual result with no
161: # padding
162: puts result_text unless result_text == ""
163: end
164: end
Prints stats, requires stats to be saved from elsewhere using the MCollective::RPC.stats method.
If you‘ve passed -v on the command line a detailed stat block will be printed, else just a one liner.
You can pass flags into it, at the moment only one flag is supported:
printrpcstats :caption => "Foo"
This will use "Foo" as the caption to the stats in verbose mode
# File lib/mcollective/rpc.rb, line 125
125: def printrpcstats(flags={})
126: return unless @options[:output_format] == :console
127:
128: verbose = @options[:verbose] rescue verbose = false
129: caption = flags[:caption] || "rpc stats"
130:
131: begin
132: stats = @@stats
133: rescue
134: puts("no stats to display")
135: return
136: end
137:
138: puts
139: puts stats.report(caption, verbose)
140: end
Wrapper to create clients, supposed to be used as a mixin:
include MCollective::RPC
exim = rpcclient("exim") printrpc exim.mailq
or
rpcclient("exim") do |exim|
printrpc exim.mailq
end
It will take a few flags:
:configfile => "etc/client.cfg" :options => options :exit_on_failure => true
Options would be a build up options hash from the Optionparser you can use the rpcoptions helper to create this
:exit_on_failure is true by default, and causes the application to exit if there is a failure constructing the RPC client. Set this flag to false to cause an Exception to be raised instead.
# File lib/mcollective/rpc.rb, line 61
61: def rpcclient(agent, flags = {})
62: configfile = flags[:configfile] || "/etc/mcollective/client.cfg"
63: options = flags[:options] || nil
64:
65: if flags.key?(:exit_on_failure)
66: exit_on_failure = flags[:exit_on_failure]
67: else
68: # We exit on failure by default for CLI-friendliness
69: exit_on_failure = true
70: end
71:
72: begin
73: if options
74: rpc = Client.new(agent, :configfile => options[:config], :options => options)
75: @options = rpc.options
76: else
77: rpc = Client.new(agent, :configfile => configfile)
78: @options = rpc.options
79: end
80: rescue Exception => e
81: if exit_on_failure
82: puts("Could not create RPC client: #{e}")
83: exit!
84: else
85: raise e
86: end
87: end
88:
89: if block_given?
90: yield(rpc)
91: else
92: return rpc
93: end
94: end
Creates a standard options hash, pass in a block to add extra headings etc see Optionparser
# File lib/mcollective/rpc.rb, line 22
22: def rpcoptions
23: oparser = MCollective::Optionparser.new({:verbose => false, :progress_bar => true}, "filter")
24:
25: options = oparser.parse do |parser, options|
26: if block_given?
27: yield(parser, options)
28: end
29:
30: Helpers.add_simplerpc_options(parser, options)
31: end
32:
33: return options
34: end
| Module | MCollective::Facts |
| In: |
lib/mcollective/facts.rb
lib/mcollective/facts/base.rb |
This is a class that gives access to the configured fact provider such as MCollectives::Facts::Facter that uses Reductive Labs facter
The actual provider is pluggable and configurable using the ‘factsource’ configuration option.
To develop a new factsource simply create a class under MCollective::Facts:: and provide the following classes:
self.get_fact(fact) self.has_fact?(fact)
You can also just inherit from MCollective::Facts::Base and provide just the
self.get_facts
method that should return a hash of facts.
Get the value of a fact
# File lib/mcollective/facts.rb, line 35
35: def self.[](fact)
36: PluginManager["facts_plugin"].get_fact(fact)
37: end
Get the value of a fact
# File lib/mcollective/facts.rb, line 30
30: def self.get_fact(fact)
31: PluginManager["facts_plugin"].get_fact(fact)
32: end
| Class | MCollective::RPCError |
| In: |
lib/mcollective.rb
|
| Parent: | StandardError |
Exceptions for the RPC system
| Module | MCollective::Matcher |
| In: |
lib/mcollective/matcher/scanner.rb
lib/mcollective/matcher/parser.rb lib/mcollective/matcher.rb |
A parser and scanner that creates a stack machine for a simple fact and class matching language used on the CLI to facilitate a rich discovery language
Language EBNF
compound = ["("] expression [")"] {["("] expression [")"]} expression = [!|not]statement ["and"|"or"] [!|not] statement char = A-Z | a-z | < | > | => | =< | _ | - |* | / { A-Z | a-z | < | > | => | =< | _ | - | * | / | } int = 0|1|2|3|4|5|6|7|8|9{|0|1|2|3|4|5|6|7|8|9|0}
| Class | MCollective::Message |
| In: |
lib/mcollective/message.rb
|
| Parent: | Object |
container for a message, its headers, agent, collective and other meta data
| VALIDTYPES | = | [:message, :request, :direct_request, :reply] |
| agent | [RW] | |
| collective | [RW] | |
| discovered_hosts | [RW] | |
| expected_msgid | [R] | |
| filter | [RW] | |
| headers | [RW] | |
| message | [R] | |
| msgtime | [R] | |
| options | [RW] | |
| payload | [R] | |
| reply_to | [R] | |
| request | [R] | |
| requestid | [RW] | |
| ttl | [RW] | |
| type | [R] | |
| validated | [R] |
payload - the message body without headers etc, just the text message - the original message received from the middleware options[:base64] - if the body base64 encoded? options[:agent] - the agent the message is for/from options[:collective] - the collective its for/from options[:headers] - the message headers options[:type] - an indicator about the type of message, :message, :request, :direct_request or :reply options[:request] - if this is a reply this should old the message we are replying to options[:filter] - for requests, the filter to encode into the message options[:options] - the normal client options hash options[:ttl] - the maximum amount of seconds this message can be valid for options[:expected_msgid] - in the case of replies this is the msgid it is expecting in the replies
# File lib/mcollective/message.rb, line 22
22: def initialize(payload, message, options = {})
23: options = {:base64 => false,
24: :agent => nil,
25: :headers => {},
26: :type => :message,
27: :request => nil,
28: :filter => Util.empty_filter,
29: :options => {},
30: :ttl => 60,
31: :expected_msgid => nil,
32: :collective => nil}.merge(options)
33:
34: @payload = payload
35: @message = message
36: @requestid = nil
37: @discovered_hosts = nil
38: @reply_to = nil
39:
40: @type = options[:type]
41: @headers = options[:headers]
42: @base64 = options[:base64]
43: @filter = options[:filter]
44: @expected_msgid = options[:expected_msgid]
45: @options = options[:options]
46:
47: @ttl = @options[:ttl] || Config.instance.ttl
48: @msgtime = 0
49:
50: @validated = false
51:
52: if options[:request]
53: @request = options[:request]
54: @agent = request.agent
55: @collective = request.collective
56: @type = :reply
57: else
58: @agent = options[:agent]
59: @collective = options[:collective]
60: end
61:
62: base64_decode!
63: end
# File lib/mcollective/message.rb, line 107
107: def base64_decode!
108: return unless @base64
109:
110: @payload = SSL.base64_decode(@payload)
111: @base64 = false
112: end
# File lib/mcollective/message.rb, line 114
114: def base64_encode!
115: return if @base64
116:
117: @payload = SSL.base64_encode(@payload)
118: @base64 = true
119: end
# File lib/mcollective/message.rb, line 197
197: def create_reqid
198: Digest::MD5.hexdigest("#{Config.instance.identity}-#{Time.now.to_f}-#{agent}-#{collective}")
199: end
# File lib/mcollective/message.rb, line 141
141: def decode!
142: raise "Cannot decode message type #{type}" unless [:request, :reply].include?(type)
143:
144: @payload = PluginManager["security_plugin"].decodemsg(self)
145:
146: if type == :request
147: raise 'callerid in request is not valid, surpressing reply to potentially forged request' unless PluginManager["security_plugin"].valid_callerid?(payload[:callerid])
148: end
149:
150: [:collective, :agent, :filter, :requestid, :ttl, :msgtime].each do |prop|
151: instance_variable_set("@#{prop}", payload[prop]) if payload.include?(prop)
152: end
153: end
# File lib/mcollective/message.rb, line 125
125: def encode!
126: case type
127: when :reply
128: raise "Cannot encode a reply message if no request has been associated with it" unless request
129: raise 'callerid in original request is not valid, surpressing reply to potentially forged request' unless PluginManager["security_plugin"].valid_callerid?(request.payload[:callerid])
130:
131: @requestid = request.payload[:requestid]
132: @payload = PluginManager["security_plugin"].encodereply(agent, payload, requestid, request.payload[:callerid])
133: when :request, :direct_request
134: @requestid = create_reqid
135: @payload = PluginManager["security_plugin"].encoderequest(Config.instance.identity, payload, requestid, filter, agent, collective, ttl)
136: else
137: raise "Cannot encode #{type} messages"
138: end
139: end
in the case of reply messages we are expecting replies to a previously created message. This stores a hint to that previously sent message id and can be used by other classes like the security plugins as a means of optimizing their behavior like by ignoring messages not directed at us.
# File lib/mcollective/message.rb, line 102
102: def expected_msgid=(msgid)
103: raise "Can only store the expected msgid for reply messages" unless @type == :reply
104: @expected_msgid = msgid
105: end
publish a reply message by creating a target name and sending it
# File lib/mcollective/message.rb, line 179
179: def publish
180: Timeout.timeout(2) do
181: # If we've been specificaly told about hosts that were discovered
182: # use that information to do P2P calls if appropriate else just
183: # send it as is.
184: if @discovered_hosts && Config.instance.direct_addressing
185: if @discovered_hosts.size <= Config.instance.direct_addressing_threshold
186: @type = :direct_request
187: Log.debug("Handling #{requestid} as a direct request")
188: end
189:
190: PluginManager["connector_plugin"].publish(self)
191: else
192: PluginManager["connector_plugin"].publish(self)
193: end
194: end
195: end
Sets a custom reply-to target for requests. The connector plugin should inspect this when constructing requests and set this header ensuring replies will go to the custom target otherwise the connector should just do what it usually does
# File lib/mcollective/message.rb, line 91
91: def reply_to=(target)
92: raise "Custom reply targets can only be set on requests" unless [:request, :direct_request].include?(@type)
93:
94: @reply_to = target
95: end
Sets the message type to one of the known types. In the case of :direct_request the list of hosts to communicate with should have been set with discovered_hosts else an exception will be raised. This is for extra security, we never accidentally want to send a direct request without a list of hosts or something weird like that as it might result in a filterless broadcast being sent.
Additionally you simply cannot set :direct_request if direct_addressing was not enabled this is to force a workflow that doesnt not yield in a mistake when someone might assume direct_addressing is enabled when its not.
# File lib/mcollective/message.rb, line 74
74: def type=(type)
75: if type == :direct_request
76: raise "Direct requests is not enabled using the direct_addressing config option" unless Config.instance.direct_addressing
77:
78: unless @discovered_hosts && !@discovered_hosts.empty?
79: raise "Can only set type to :direct_request if discovered_hosts have been set"
80: end
81: end
82:
83: raise "Unknown message type #{type}" unless VALIDTYPES.include?(type)
84:
85: @type = type
86: end
Perform validation against the message by checking filters and ttl
# File lib/mcollective/message.rb, line 156
156: def validate
157: raise "Can only validate request messages" unless type == :request
158:
159: msg_age = Time.now.utc.to_i - msgtime
160:
161: if msg_age > ttl
162: cid = ""
163: cid += payload[:callerid] + "@" if payload.include?(:callerid)
164: cid += payload[:senderid]
165:
166: if msg_age > ttl
167: PluginManager["global_stats"].ttlexpired
168:
169: raise(MsgTTLExpired, "Message #{requestid} from #{cid} created at #{msgtime} is #{msg_age} seconds old, TTL is #{ttl}")
170: end
171: end
172:
173: raise(NotTargettedAtUs, "Received message is not targetted to us") unless PluginManager["security_plugin"].validate_filter?(payload[:filter])
174:
175: @validated = true
176: end
| Class | MCollective::Security::Base |
| In: |
lib/mcollective/security/base.rb
|
| Parent: | Object |
This is a base class the other security modules should inherit from it handles statistics and validation of messages that should in most cases apply to all security models.
To create your own security plugin you should provide a plugin that inherits from this and provides the following methods:
decodemsg - Decodes a message that was received from the middleware encodereply - Encodes a reply message to a previous request message encoderequest - Encodes a new request message validrequest? - Validates a request received from the middleware
Optionally if you are identifying users by some other means like certificate name you can provide your own callerid method that can provide the rest of the system with an id, and you would see this id being usable in SimpleRPC authorization methods
The @initiated_by variable will be set to either :client or :node depending on who is using this plugin. This is to help security providers that operate in an asymetric mode like public/private key based systems.
Specifics of each of these are a bit fluid and the interfaces for this is not set in stone yet, specifically the encode methods will be provided with a helper that takes care of encoding the core requirements. The best place to see how security works is by looking at the provided MCollective::Security::PSK plugin.
| initiated_by | [RW] | |
| stats | [R] |
Register plugins that inherits base
# File lib/mcollective/security/base.rb, line 32
32: def self.inherited(klass)
33: PluginManager << {:type => "security_plugin", :class => klass.to_s}
34: end
Initializes configuration and logging as well as prepare a zero‘d hash of stats various security methods and filter validators should increment stats, see MCollective::Security::Psk for a sample
# File lib/mcollective/security/base.rb, line 38
38: def initialize
39: @config = Config.instance
40: @log = Log
41: @stats = PluginManager["global_stats"]
42: end
Returns a unique id for the caller, by default we just use the unix user id, security plugins can provide their own means of doing ids.
# File lib/mcollective/security/base.rb, line 212
212: def callerid
213: "uid=#{Process.uid}"
214: end
# File lib/mcollective/security/base.rb, line 160
160: def create_reply(reqid, agent, body)
161: Log.debug("Encoded a message for request #{reqid}")
162:
163: {:senderid => @config.identity,
164: :requestid => reqid,
165: :senderagent => agent,
166: :msgtime => Time.now.utc.to_i,
167: :body => body}
168: end
# File lib/mcollective/security/base.rb, line 170
170: def create_request(reqid, filter, msg, initiated_by, target_agent, target_collective, ttl=60)
171: Log.debug("Encoding a request for agent '#{target_agent}' in collective #{target_collective} with request id #{reqid}")
172:
173: {:body => msg,
174: :senderid => @config.identity,
175: :requestid => reqid,
176: :filter => filter,
177: :collective => target_collective,
178: :agent => target_agent,
179: :callerid => callerid,
180: :ttl => ttl,
181: :msgtime => Time.now.utc.to_i}
182: end
Give a MC::Message instance and a message id this will figure out if you the incoming message id matches the one the Message object is expecting and raise if its not
Mostly used by security plugins to figure out if they should do the hard work of decrypting etc messages that would only later on be ignored
# File lib/mcollective/security/base.rb, line 189
189: def should_process_msg?(msg, msgid)
190: if msg.expected_msgid
191: unless msg.expected_msgid == msgid
192: msgtext = "Got a message with id %s but was expecting %s, ignoring message" % [msgid, msg.expected_msgid]
193: Log.debug msgtext
194: raise MsgDoesNotMatchRequestID, msgtext
195: end
196: end
197:
198: true
199: end
Validates a callerid. We do not want to allow things like \ and / in callerids since other plugins make assumptions that these are safe strings.
callerids are generally in the form uid=123 or cert=foo etc so we do that here but security plugins could override this for some complex uses
# File lib/mcollective/security/base.rb, line 206
206: def valid_callerid?(id)
207: !!id.match(/^[\w]+=[\w\.\-]+$/)
208: end
Takes a Hash with a filter in it and validates it against host information.
At present this supports filter matches against the following criteria:
the file configured with classesfile
TODO: Support REGEX and/or multiple filter keys to be AND‘d
# File lib/mcollective/security/base.rb, line 55
55: def validate_filter?(filter)
56: failed = 0
57: passed = 0
58:
59: passed = 1 if Util.empty_filter?(filter)
60:
61: filter.keys.each do |key|
62: case key
63: when /puppet_class|cf_class/
64: filter[key].each do |f|
65: Log.debug("Checking for class #{f}")
66: if Util.has_cf_class?(f) then
67: Log.debug("Passing based on configuration management class #{f}")
68: passed += 1
69: else
70: Log.debug("Failing based on configuration management class #{f}")
71: failed += 1
72: end
73: end
74:
75: when "compound"
76: filter[key].each do |compound|
77: result = []
78:
79: compound.each do |expression|
80: case expression.keys.first
81: when "statement"
82: result << Util.eval_compound_statement(expression).to_s
83: when "and"
84: result << "&&"
85: when "or"
86: result << "||"
87: when "("
88: result << "("
89: when ")"
90: result << ")"
91: when "not"
92: result << "!"
93: end
94: end
95:
96: result = eval(result.join(" "))
97:
98: if result
99: Log.debug("Passing based on class and fact composition")
100: passed +=1
101: else
102: Log.debug("Failing based on class and fact composition")
103: failed +=1
104: end
105: end
106:
107: when "agent"
108: filter[key].each do |f|
109: if Util.has_agent?(f) || f == "mcollective"
110: Log.debug("Passing based on agent #{f}")
111: passed += 1
112: else
113: Log.debug("Failing based on agent #{f}")
114: failed += 1
115: end
116: end
117:
118: when "fact"
119: filter[key].each do |f|
120: if Util.has_fact?(f[:fact], f[:value], f[:operator])
121: Log.debug("Passing based on fact #{f[:fact]} #{f[:operator]} #{f[:value]}")
122: passed += 1
123: else
124: Log.debug("Failing based on fact #{f[:fact]} #{f[:operator]} #{f[:value]}")
125: failed += 1
126: end
127: end
128:
129: when "identity"
130: unless filter[key].empty?
131: # Identity filters should not be 'and' but 'or' as each node can only have one identity
132: matched = filter[key].select{|f| Util.has_identity?(f)}.size
133:
134: if matched == 1
135: Log.debug("Passing based on identity")
136: passed += 1
137: else
138: Log.debug("Failed based on identity")
139: failed += 1
140: end
141: end
142: end
143: end
144:
145: if failed == 0 && passed > 0
146: Log.debug("Message passed the filter checks")
147:
148: @stats.passed
149:
150: return true
151: else
152: Log.debug("Message failed the filter checks")
153:
154: @stats.filtered
155:
156: return false
157: end
158: end
| Class | MCollective::InvalidRPCData |
| In: |
lib/mcollective.rb
|
| Parent: | RPCError |
| Class | MCollective::RPC::Reply |
| In: |
lib/mcollective/rpc/reply.rb
|
| Parent: | Object |
| data | [RW] | |
| statuscode | [RW] | |
| statusmsg | [RW] |
# File lib/mcollective/rpc/reply.rb, line 7
7: def initialize
8: @data = {}
9: @statuscode = 0
10: @statusmsg = "OK"
11: end
Read from the data hash
# File lib/mcollective/rpc/reply.rb, line 48
48: def [](key)
49: @data[key]
50: end
Write to the data hash
# File lib/mcollective/rpc/reply.rb, line 43
43: def []=(key, val)
44: @data[key] = val
45: end
Helper to fill in statusmsg and code on failure
# File lib/mcollective/rpc/reply.rb, line 14
14: def fail(msg, code=1)
15: @statusmsg = msg
16: @statuscode = code
17: end
Helper that fills in statusmsg and code but also raises an appropriate error
# File lib/mcollective/rpc/reply.rb, line 20
20: def fail!(msg, code=1)
21: @statusmsg = msg
22: @statuscode = code
23:
24: case code
25: when 1
26: raise RPCAborted, msg
27:
28: when 2
29: raise UnknownRPCAction, msg
30:
31: when 3
32: raise MissingRPCData, msg
33:
34: when 4
35: raise InvalidRPCData, msg
36:
37: else
38: raise UnknownRPCError, msg
39: end
40: end
| Class | MCollective::RPC::Result |
| In: |
lib/mcollective/rpc/result.rb
|
| Parent: | Object |
Simple class to manage compliant results from MCollective::RPC agents
Currently it just fakes Hash behaviour to the result to remain backward compatible but it also knows which agent and action produced it so you can associate results to a DDL
| action | [R] | |
| agent | [R] | |
| results | [R] |
# File lib/mcollective/rpc/result.rb, line 13
13: def initialize(agent, action, result={})
14: @agent = agent
15: @action = action
16: @results = result
17: end
# File lib/mcollective/rpc/result.rb, line 23
23: def []=(idx, item)
24: @results[idx] = item
25: end
# File lib/mcollective/rpc/result.rb, line 27
27: def each
28: @results.each_pair {|k,v| yield(k,v) }
29: end
| Class | MCollective::RPC::Agent |
| In: |
lib/mcollective/rpc/agent.rb
|
| Parent: | Object |
A wrapper around the traditional agent, it takes care of a lot of the tedious setup you would do for each agent allowing you to just create methods following a naming standard leaving the heavy lifting up to this clas.
See marionette-collective.org/simplerpc/agents.html
It only really makes sense to use this with a Simple RPC client on the other end, basic usage would be:
module MCollective
module Agent
class Helloworld<RPC::Agent
matadata :name => "Test SimpleRPC Agent",
:description => "A simple test",
:author => "You",
:license => "1.1",
:url => "http://your.com/,
:timeout => 60
action "hello" do
reply[:msg] = "Hello #{request[:name]}"
end
action "foo" do
implemented_by "/some/script.sh"
end
end
end
end
If you wish to implement the logic for an action using an external script use the implemented_by method that will cause your script to be run with 2 arguments.
The first argument is a file containing JSON with the request and the 2nd argument is where the script should save its output as a JSON hash.
We also currently have the validation code in here, this will be moved to plugins soon.
| config | [R] | |
| ddl | [R] | |
| logger | [R] | |
| meta | [RW] | |
| reply | [RW] | |
| request | [RW] | |
| timeout | [R] |
By default RPC Agents support a toggle in the configuration that can enable and disable them based on the agent name
Example an agent called Foo can have:
plugin.foo.activate_agent = false
and this will prevent the agent from loading on this particular machine.
Agents can use the activate_when helper to override this for example:
activate_when do
File.exist?("/usr/bin/puppet")
end
# File lib/mcollective/rpc/agent.rb, line 143
143: def self.activate?
144: agent_name = self.to_s.split("::").last.downcase
145:
146: Log.debug("Starting default activation checks for #{agent_name}")
147:
148: should_activate = Config.instance.pluginconf["#{agent_name}.activate_agent"]
149:
150: if should_activate
151: Log.debug("Found plugin config #{agent_name}.activate_agent with value #{should_activate}")
152: unless should_activate =~ /^1|y|true$/
153: return false
154: end
155: end
156:
157: return true
158: end
# File lib/mcollective/rpc/agent.rb, line 44
44: def initialize
45: # Default meta data unset
46: @meta = {:timeout => 10,
47: :name => "Unknown",
48: :description => "Unknown",
49: :author => "Unknown",
50: :license => "Unknown",
51: :version => "Unknown",
52: :url => "Unknown"}
53:
54: @timeout = meta[:timeout] || 10
55: @logger = Log.instance
56: @config = Config.instance
57: @agent_name = self.class.to_s.split("::").last.downcase
58:
59: # Loads the DDL so we can later use it for validation
60: # and help generation
61: begin
62: @ddl = DDL.new(@agent_name)
63: rescue Exception => e
64: Log.debug("Failed to load DDL for agent: #{e.class}: #{e}")
65: @ddl = nil
66: end
67:
68: # if we have a global authorization provider enable it
69: # plugins can still override it per plugin
70: self.class.authorized_by(@config.rpcauthprovider) if @config.rpcauthorization
71:
72: startup_hook
73: end
# File lib/mcollective/rpc/agent.rb, line 75
75: def handlemsg(msg, connection)
76: @request = RPC.request(msg)
77: @reply = RPC.reply
78:
79: begin
80: # Calls the authorization plugin if any is defined
81: # if this raises an exception we wil just skip processing this
82: # message
83: authorization_hook(@request) if respond_to?("authorization_hook")
84:
85:
86: # Audits the request, currently continues processing the message
87: # we should make this a configurable so that an audit failure means
88: # a message wont be processed by this node depending on config
89: audit_request(@request, connection)
90:
91: before_processing_hook(msg, connection)
92:
93: if respond_to?("#{@request.action}_action")
94: send("#{@request.action}_action")
95: else
96: raise UnknownRPCAction, "Unknown action: #{@request.action}"
97: end
98: rescue RPCAborted => e
99: @reply.fail e.to_s, 1
100:
101: rescue UnknownRPCAction => e
102: @reply.fail e.to_s, 2
103:
104: rescue MissingRPCData => e
105: @reply.fail e.to_s, 3
106:
107: rescue InvalidRPCData => e
108: @reply.fail e.to_s, 4
109:
110: rescue UnknownRPCError => e
111: @reply.fail e.to_s, 5
112:
113: rescue Exception => e
114: @reply.fail e.to_s, 5
115:
116: end
117:
118: after_processing_hook
119:
120: if @request.should_respond?
121: return @reply.to_hash
122: else
123: Log.debug("Client did not request a response, surpressing reply")
124: return nil
125: end
126: end
| Class | MCollective::RPC::Audit |
| In: |
lib/mcollective/rpc/audit.rb
|
| Parent: | Object |
Auditing of requests is done only for SimpleRPC requests, you provide a plugin in the MCollective::Audit::* namespace which the SimpleRPC framework calls for each message
We provide a simple one that logs to a logfile in the class MCollective::Audit::Logfile you can create your own:
Create a class in plugins/mcollective/audit/<yourplugin>.rb
You must inherit from MCollective::RPC::Audit which will take care of registering you with the plugin system.
Your plugin must provide audit_request(request, connection) the request parameter will be an instance of MCollective::RPC::Request
To enable auditing you should set:
rpcaudit = 1 rpcauditprovider = Logfile
in the config file this will enable logging using the MCollective::Audit::Logile class
The Audit class acts as a base for audit plugins and takes care of registering them with the plugin manager
# File lib/mcollective/rpc/audit.rb, line 29
29: def self.inherited(klass)
30: PluginManager << {:type => "rpcaudit_plugin", :class => klass.to_s}
31: end
| Class | MCollective::RPC::ActionRunner |
| In: |
lib/mcollective/rpc/actionrunner.rb
|
| Parent: | Object |
A helper used by RPC::Agent#implemented_by to delegate an action to an external script. At present only JSON based serialization is supported in future ones based on key=val pairs etc will be added
It serializes the request object into an input file and creates an empty output file. It then calls the external command reading the output file at the end.
any STDERR gets logged at error level and any STDOUT gets logged at info level.
It will interpret the exit code from the application the same way RPC::Reply#fail! and fail handles their codes creating a consistent interface, the message part of the fail message will come from STDERR
Generally externals should just exit with code 1 on failure and print to STDERR, this is exactly what Perl die() does and translates perfectly to our model
It uses the MCollective::Shell wrapper to call the external application
| action | [R] | |
| agent | [R] | |
| command | [R] | |
| format | [R] | |
| request | [R] | |
| stderr | [R] | |
| stdout | [R] |
# File lib/mcollective/rpc/actionrunner.rb, line 26
26: def initialize(command, request, format=:json)
27: @agent = request.agent
28: @action = request.action
29: @format = format
30: @request = request
31: @command = path_to_command(command)
32: @stdout = ""
33: @stderr = ""
34: end
# File lib/mcollective/rpc/actionrunner.rb, line 117
117: def canrun?(command)
118: File.executable?(command)
119: end
# File lib/mcollective/rpc/actionrunner.rb, line 91
91: def load_json_results(file)
92: return {} unless File.readable?(file)
93:
94: JSON.load(File.read(file))
95: rescue JSON::ParserError
96: {}
97: end
# File lib/mcollective/rpc/actionrunner.rb, line 73
73: def load_results(file)
74: Log.debug("Attempting to load results in #{format} format from #{file}")
75:
76: data = {}
77:
78: if respond_to?("load_#{format}_results")
79: tempdata = send("load_#{format}_results", file)
80:
81: tempdata.each_pair do |k,v|
82: data[k.to_sym] = v
83: end
84: end
85:
86: data
87: rescue Exception => e
88: {}
89: end
# File lib/mcollective/rpc/actionrunner.rb, line 129
129: def path_to_command(command)
130: unless command[0,1] == File::SEPARATOR
131: Config.instance.libdir.each do |libdir|
132: command_file = File.join(libdir, "agent", agent, command)
133:
134: return command_file if File.exist?(command_file)
135: end
136: end
137:
138: return command
139: end
# File lib/mcollective/rpc/actionrunner.rb, line 36
36: def run
37: unless canrun?(command)
38: Log.warn("Cannot run #{to_s}")
39: raise RPCAborted, "Cannot execute #{to_s}"
40: end
41:
42: Log.debug("Running #{to_s}")
43:
44: request_file = saverequest(request)
45: reply_file = tempfile("reply")
46: reply_file.close
47:
48: runner = shell(command, request_file.path, reply_file.path)
49:
50: runner.runcommand
51:
52: Log.debug("#{command} exited with #{runner.status.exitstatus}")
53:
54: stderr.each_line {|l| Log.error("#{to_s}: #{l.chomp}")} unless stderr.empty?
55: stdout.each_line {|l| Log.info("#{to_s}: #{l.chomp}")} unless stdout.empty?
56:
57: {:exitstatus => runner.status.exitstatus,
58: :stdout => runner.stdout,
59: :stderr => runner.stderr,
60: :data => load_results(reply_file.path)}
61: ensure
62: request_file.close! if request_file.respond_to?("close!")
63: reply_file.close! if reply_file.respond_to?("close")
64: end
# File lib/mcollective/rpc/actionrunner.rb, line 113
113: def save_json_request(req)
114: req.to_json
115: end
# File lib/mcollective/rpc/actionrunner.rb, line 99
99: def saverequest(req)
100: Log.debug("Attempting to save request in #{format} format")
101:
102: if respond_to?("save_#{format}_request")
103: data = send("save_#{format}_request", req)
104:
105: request_file = tempfile("request")
106: request_file.puts data
107: request_file.close
108: end
109:
110: request_file
111: end
# File lib/mcollective/rpc/actionrunner.rb, line 66
66: def shell(command, infile, outfile)
67: env = {"MCOLLECTIVE_REQUEST_FILE" => infile,
68: "MCOLLECTIVE_REPLY_FILE" => outfile}
69:
70: Shell.new("#{command} #{infile} #{outfile}", :cwd => Dir.tmpdir, :stdout => stdout, :stderr => stderr, :environment => env)
71: end
| Class | MCollective::RPC::Client |
| In: |
lib/mcollective/rpc/client.rb
|
| Parent: | Object |
The main component of the Simple RPC client system, this wraps around MCollective::Client and just brings in a lot of convention and standard approached.
| agent | [R] | |
| batch_mode | [R] | |
| batch_size | [R] | |
| batch_sleep_time | [R] | |
| client | [R] | |
| config | [RW] | |
| ddl | [R] | |
| discovery_timeout | [RW] | |
| filter | [RW] | |
| limit_method | [R] | |
| limit_targets | [R] | |
| output_format | [R] | |
| progress | [RW] | |
| reply_to | [RW] | |
| stats | [R] | |
| timeout | [RW] | |
| ttl | [RW] | |
| verbose | [RW] |
Creates a stub for a remote agent, you can pass in an options array in the flags which will then be used else it will just create a default options array with filtering enabled based on the standard command line use.
rpc = RPC::Client.new("rpctest", :configfile => "client.cfg", :options => options)
You typically would not call this directly you‘d use MCollective::RPC#rpcclient instead which is a wrapper around this that can be used as a Mixin
# File lib/mcollective/rpc/client.rb, line 19
19: def initialize(agent, flags = {})
20: if flags.include?(:options)
21: initial_options = flags[:options]
22:
23: elsif @@initial_options
24: initial_options = Marshal.load(@@initial_options)
25:
26: else
27: oparser = MCollective::Optionparser.new({:verbose => false, :progress_bar => true, :mcollective_limit_targets => false, :batch_size => nil, :batch_sleep_time => 1}, "filter")
28:
29: initial_options = oparser.parse do |parser, opts|
30: if block_given?
31: yield(parser, opts)
32: end
33:
34: Helpers.add_simplerpc_options(parser, opts)
35: end
36:
37: @@initial_options = Marshal.dump(initial_options)
38: end
39:
40: @stats = Stats.new
41: @agent = agent
42: @discovery_timeout = initial_options[:disctimeout]
43: @timeout = initial_options[:timeout]
44: @verbose = initial_options[:verbose]
45: @filter = initial_options[:filter]
46: @config = initial_options[:config]
47: @discovered_agents = nil
48: @progress = initial_options[:progress_bar]
49: @limit_targets = initial_options[:mcollective_limit_targets]
50: @limit_method = Config.instance.rpclimitmethod
51: @output_format = initial_options[:output_format] || :console
52: @force_direct_request = false
53: @reply_to = initial_options[:reply_to]
54:
55: @batch_size = Integer(initial_options[:batch_size] || 0)
56: @batch_sleep_time = Float(initial_options[:batch_sleep_time] || 1)
57: @batch_mode = @batch_size > 0
58:
59: agent_filter agent
60:
61: @client = MCollective::Client.new(@config)
62: @client.options = initial_options
63:
64: @collective = @client.collective
65: @ttl = initial_options[:ttl] || Config.instance.ttl
66:
67: # if we can find a DDL for the service override
68: # the timeout of the client so we always magically
69: # wait appropriate amounts of time.
70: #
71: # We add the discovery timeout to the ddl supplied
72: # timeout as the discovery timeout tends to be tuned
73: # for local network conditions and fact source speed
74: # which would other wise not be accounted for and
75: # some results might get missed.
76: #
77: # We do this only if the timeout is the default 5
78: # seconds, so that users cli overrides will still
79: # get applied
80: begin
81: @ddl = DDL.new(agent)
82: @timeout = @ddl.meta[:timeout] + @discovery_timeout if @timeout == 5
83: rescue Exception => e
84: Log.debug("Could not find DDL: #{e}")
85: @ddl = nil
86: end
87:
88: # allows stderr and stdout to be overridden for testing
89: # but also for web apps that might not want a bunch of stuff
90: # generated to actual file handles
91: if initial_options[:stderr]
92: @stderr = initial_options[:stderr]
93: else
94: @stderr = STDERR
95: @stderr.sync = true
96: end
97:
98: if initial_options[:stdout]
99: @stdout = initial_options[:stdout]
100: else
101: @stdout = STDOUT
102: @stdout.sync = true
103: end
104: end
Sets the agent filter
# File lib/mcollective/rpc/client.rb, line 347
347: def agent_filter(agent)
348: @filter["agent"] << agent
349: @filter["agent"].compact!
350: reset
351: end
Sets the batch size, if the size is set to 0 that will disable batch mode
# File lib/mcollective/rpc/client.rb, line 519
519: def batch_size=(limit)
520: raise "Can only set batch size if direct addressing is supported" unless Config.instance.direct_addressing
521:
522: @batch_size = Integer(limit)
523: @batch_mode = @batch_size > 0
524: end
# File lib/mcollective/rpc/client.rb, line 526
526: def batch_sleep_time=(time)
527: raise "Can only set batch sleep time if direct addressing is supported" unless Config.instance.direct_addressing
528:
529: @batch_sleep_time = Float(time)
530: end
Sets the class filter
# File lib/mcollective/rpc/client.rb, line 323
323: def class_filter(klass)
324: @filter["cf_class"] << klass
325: @filter["cf_class"].compact!
326: reset
327: end
Sets the collective we are communicating with
# File lib/mcollective/rpc/client.rb, line 487
487: def collective=(c)
488: @collective = c
489: @client.options[:collective] = c
490: end
Set a compound filter
# File lib/mcollective/rpc/client.rb, line 361
361: def compound_filter(filter)
362: @filter["compound"] << Matcher::Parser.new(filter).execution_stack
363: reset
364: end
Constructs custom requests with custom filters and discovery data the idea is that this would be used in web applications where you might be using a cached copy of data provided by a registration agent to figure out on your own what nodes will be responding and what your filter would be.
This will help you essentially short circuit the traditional cycle of:
mc discover / call / wait for discovered nodes
by doing discovery however you like, contructing a filter and a list of nodes you expect responses from.
Other than that it will work exactly like a normal call, blocks will behave the same way, stats will be handled the same way etcetc
If you just wanted to contact one machine for example with a client that already has other filter options setup you can do:
puppet.custom_request("runonce", {}, ["your.box.com"], {:identity => "your.box.com"})
This will do runonce action on just ‘your.box.com’, no discovery will be done and after receiving just one response it will stop waiting for responses
If direct_addressing is enabled in the config file you can provide an empty hash as a filter, this will force that request to be a directly addressed request which technically does not need filters. If you try to use this mode with direct addressing disabled an exception will be raise
# File lib/mcollective/rpc/client.rb, line 274
274: def custom_request(action, args, expected_agents, filter = {}, &block)
275: @ddl.validate_request(action, args) if @ddl
276:
277: if filter == {} && !Config.instance.direct_addressing
278: raise "Attempted to do a filterless custom_request without direct_addressing enabled, preventing unexpected call to all nodes"
279: end
280:
281: @stats.reset
282:
283: custom_filter = Util.empty_filter
284: custom_options = options.clone
285:
286: # merge the supplied filter with the standard empty one
287: # we could just use the merge method but I want to be sure
288: # we dont merge in stuff that isnt actually valid
289: ["identity", "fact", "agent", "cf_class", "compound"].each do |ftype|
290: if filter.include?(ftype)
291: custom_filter[ftype] = [filter[ftype], custom_filter[ftype]].flatten
292: end
293: end
294:
295: # ensure that all filters at least restrict the call to the agent we're a proxy for
296: custom_filter["agent"] << @agent unless custom_filter["agent"].include?(@agent)
297: custom_options[:filter] = custom_filter
298:
299: # Fake out the stats discovery would have put there
300: @stats.discovered_agents([expected_agents].flatten)
301:
302: # Handle fire and forget requests
303: #
304: # If a specific reply-to was set then from the client perspective this should
305: # be a fire and forget request too since no response will ever reach us - it
306: # will go to the reply-to destination
307: if args[:process_results] == false || @reply_to
308: return fire_and_forget_request(action, args, custom_filter)
309: end
310:
311: # Now do a call pretty much exactly like in method_missing except with our own
312: # options and discovery magic
313: if block_given?
314: call_agent(action, args, custom_options, [expected_agents].flatten) do |r|
315: block.call(r)
316: end
317: else
318: call_agent(action, args, custom_options, [expected_agents].flatten)
319: end
320: end
Disconnects cleanly from the middleware
# File lib/mcollective/rpc/client.rb, line 107
107: def disconnect
108: @client.disconnect
109: end
Does discovery based on the filters set, if a discovery was previously done return that else do a new discovery.
Alternatively if identity filters are given and none of them are regular expressions then just use the provided data as discovered data, avoiding discovery
Discovery can be forced if direct_addressing is enabled by passing in an array of nodes with :nodes or JSON data like those produced by mcollective RPC JSON output using :json
Will show a message indicating its doing discovery if running verbose or if the :verbose flag is passed in.
Use reset to force a new discovery
# File lib/mcollective/rpc/client.rb, line 393
393: def discover(flags={})
394: flags.keys.each do |key|
395: raise "Unknown option #{key} passed to discover" unless [:verbose, :hosts, :nodes, :json].include?(key)
396: end
397:
398: flags.include?(:verbose) ? verbose = flags[:verbose] : verbose = @verbose
399:
400: verbose = false unless @output_format == :console
401:
402: # flags[:nodes] and flags[:hosts] are the same thing, we should never have
403: # allowed :hosts as that was inconsistent with the established terminology
404: flags[:nodes] = flags.delete(:hosts) if flags.include?(:hosts)
405:
406: reset if flags[:nodes] || flags[:json]
407:
408: unless @discovered_agents
409: # if either hosts or JSON is supplied try to figure out discovery data from there
410: # if direct_addressing is not enabled this is a critical error as the user might
411: # not have supplied filters so raise an exception
412: if flags[:nodes] || flags[:json]
413: raise "Can only supply discovery data if direct_addressing is enabled" unless Config.instance.direct_addressing
414:
415: hosts = []
416:
417: if flags[:nodes]
418: hosts = Helpers.extract_hosts_from_array(flags[:nodes])
419: elsif flags[:json]
420: hosts = Helpers.extract_hosts_from_json(flags[:json])
421: end
422:
423: raise "Could not find any hosts in discovery data provided" if hosts.empty?
424:
425: @discovered_agents = hosts
426: @force_direct_request = true
427:
428: # if an identity filter is supplied and it is all strings no regex we can use that
429: # as discovery data, technically the identity filter is then redundant if we are
430: # in direct addressing mode and we could empty it out but this use case should
431: # only really be for a few -I's on the CLI
432: #
433: # For safety we leave the filter in place for now, that way we can support this
434: # enhancement also in broadcast mode
435: elsif options[:filter]["identity"].size > 0
436: regex_filters = options[:filter]["identity"].select{|i| i.match("^\/")}.size
437:
438: if regex_filters == 0
439: @discovered_agents = options[:filter]["identity"].clone
440: @force_direct_request = true if Config.instance.direct_addressing
441: end
442: end
443: end
444:
445: # All else fails we do it the hard way using a traditional broadcast
446: unless @discovered_agents
447: @stats.time_discovery :start
448:
449: @stderr.print("Determining the amount of hosts matching filter for #{discovery_timeout} seconds .... ") if verbose
450:
451: # if the requested limit is a pure number and not a percent
452: # and if we're configured to use the first found hosts as the
453: # limit method then pass in the limit thus minimizing the amount
454: # of work we do in the discover phase and speeding it up significantly
455: if @limit_method == :first and @limit_targets.is_a?(Fixnum)
456: @discovered_agents = @client.discover(@filter, @discovery_timeout, @limit_targets)
457: else
458: @discovered_agents = @client.discover(@filter, @discovery_timeout)
459: end
460:
461: @force_direct_request = false
462: @stderr.puts(@discovered_agents.size) if verbose
463:
464: @stats.time_discovery :end
465: end
466:
467: @stats.discovered_agents(@discovered_agents)
468: RPC.discovered(@discovered_agents)
469:
470: @discovered_agents
471: end
Sets the fact filter
# File lib/mcollective/rpc/client.rb, line 330
330: def fact_filter(fact, value=nil, operator="=")
331: return if fact.nil?
332: return if fact == false
333:
334: if value.nil?
335: parsed = Util.parse_fact_string(fact)
336: @filter["fact"] << parsed unless parsed == false
337: else
338: parsed = Util.parse_fact_string("#{fact}#{operator}#{value}")
339: @filter["fact"] << parsed unless parsed == false
340: end
341:
342: @filter["fact"].compact!
343: reset
344: end
Sets the identity filter
# File lib/mcollective/rpc/client.rb, line 354
354: def identity_filter(identity)
355: @filter["identity"] << identity
356: @filter["identity"].compact!
357: reset
358: end
Sets and sanity check the limit_method variable used to determine how to limit targets if limit_targets is set
# File lib/mcollective/rpc/client.rb, line 510
510: def limit_method=(method)
511: method = method.to_sym unless method.is_a?(Symbol)
512:
513: raise "Unknown limit method #{method} must be :random or :first" unless [:random, :first].include?(method)
514:
515: @limit_method = method
516: end
Sets and sanity checks the limit_targets variable used to restrict how many nodes we‘ll target
# File lib/mcollective/rpc/client.rb, line 494
494: def limit_targets=(limit)
495: if limit.is_a?(String)
496: raise "Invalid limit specified: #{limit} valid limits are /^\d+%*$/" unless limit =~ /^\d+%*$/
497:
498: begin
499: @limit_targets = Integer(limit)
500: rescue
501: @limit_targets = limit
502: end
503: else
504: @limit_targets = Integer(limit)
505: end
506: end
Magic handler to invoke remote methods
Once the stub is created using the constructor or the RPC#rpcclient helper you can call remote actions easily:
ret = rpc.echo(:msg => "hello world")
This will call the ‘echo’ action of the ‘rpctest’ agent and return the result as an array, the array will be a simplified result set from the usual full MCollective::Client#req with additional error codes and error text:
{
:sender => "remote.box.com", :statuscode => 0, :statusmsg => "OK", :data => "hello world"
}
If :statuscode is 0 then everything went find, if it‘s 1 then you supplied the correct arguments etc but the request could not be completed, you‘ll find a human parsable reason in :statusmsg then.
Codes 2 to 5 maps directly to UnknownRPCAction, MissingRPCData, InvalidRPCData and UnknownRPCError see below for a description of those, in each case :statusmsg would be the reason for failure.
To get access to the full result of the MCollective::Client#req calls you can pass in a block:
rpc.echo(:msg => "hello world") do |resp|
pp resp
end
In this case resp will the result from MCollective::Client#req. Instead of returning simple text and codes as above you‘ll also need to handle the following exceptions:
UnknownRPCAction - There is no matching action on the agent MissingRPCData - You did not supply all the needed parameters for the action InvalidRPCData - The data you did supply did not pass validation UnknownRPCError - Some other error prevented the agent from running
During calls a progress indicator will be shown of how many results we‘ve received against how many nodes were discovered, you can disable this by setting progress to false:
rpc.progress = false
This supports a 2nd mode where it will send the SimpleRPC request and never handle the responses. It‘s a bit like UDP, it sends the request with the filter attached and you only get back the requestid, you have no indication about results.
You can invoke this using:
puts rpc.echo(:process_results => false)
This will output just the request id.
Batched processing is supported:
printrpc rpc.ping(:batch_size => 5)
This will do everything exactly as normal but communicate to only 5 agents at a time
# File lib/mcollective/rpc/client.rb, line 209
209: def method_missing(method_name, *args, &block)
210: # set args to an empty hash if nothings given
211: args = args[0]
212: args = {} if args.nil?
213:
214: action = method_name.to_s
215:
216: @stats.reset
217:
218: @ddl.validate_request(action, args) if @ddl
219:
220: # if a global batch size is set just use that else set it
221: # in the case that it was passed as an argument
222: batch_mode = args.include?(:batch_size) || @batch_mode
223: batch_size = args.delete(:batch_size) || @batch_size
224: batch_sleep_time = args.delete(:batch_sleep_time) || @batch_sleep_time
225:
226: # if we were given a batch_size argument thats 0 and batch_mode was
227: # determined to be on via global options etc this will allow a batch_size
228: # of 0 to disable or batch_mode for this call only
229: batch_mode = (batch_mode && Integer(batch_size) > 0)
230:
231: # Handle single target requests by doing discovery and picking
232: # a random node. Then do a custom request specifying a filter
233: # that will only match the one node.
234: if @limit_targets
235: target_nodes = pick_nodes_from_discovered(@limit_targets)
236: Log.debug("Picked #{target_nodes.join(',')} as limited target(s)")
237:
238: custom_request(action, args, target_nodes, {"identity" => /^(#{target_nodes.join('|')})$/}, &block)
239: elsif batch_mode
240: call_agent_batched(action, args, options, batch_size, batch_sleep_time, &block)
241: else
242: call_agent(action, args, options, :auto, &block)
243: end
244: end
Creates a suitable request hash for the SimpleRPC agent.
You‘d use this if you ever wanted to take care of sending requests on your own - perhaps via Client#sendreq if you didn‘t care for responses.
In that case you can just do:
msg = your_rpc.new_request("some_action", :foo => :bar)
filter = your_rpc.filter
your_rpc.client.sendreq(msg, msg[:agent], filter)
This will send a SimpleRPC request to the action some_action with arguments :foo = :bar, it will return immediately and you will have no indication at all if the request was receieved or not
Clearly the use of this technique should be limited and done only if your code requires such a thing
# File lib/mcollective/rpc/client.rb, line 139
139: def new_request(action, data)
140: callerid = PluginManager["security_plugin"].callerid
141:
142: raise 'callerid received from security plugin is not valid' unless PluginManager["security_plugin"].valid_callerid?(callerid)
143:
144: {:agent => @agent,
145: :action => action,
146: :caller => callerid,
147: :data => data}
148: end
Provides a normal options hash like you would get from Optionparser
# File lib/mcollective/rpc/client.rb, line 475
475: def options
476: {:disctimeout => @discovery_timeout,
477: :timeout => @timeout,
478: :verbose => @verbose,
479: :filter => @filter,
480: :collective => @collective,
481: :output_format => @output_format,
482: :ttl => @ttl,
483: :config => @config}
484: end
Resets various internal parts of the class, most importantly it clears out the cached discovery
# File lib/mcollective/rpc/client.rb, line 368
368: def reset
369: @discovered_agents = nil
370: end
| Class | MCollective::RPC::Request |
| In: |
lib/mcollective/rpc/request.rb
|
| Parent: | Object |
Simple class to manage compliant requests for MCollective::RPC agents
| action | [RW] | |
| agent | [RW] | |
| caller | [RW] | |
| data | [RW] | |
| sender | [RW] | |
| time | [RW] | |
| uniqid | [RW] |
# File lib/mcollective/rpc/request.rb, line 7
7: def initialize(msg)
8: @time = msg[:msgtime]
9: @action = msg[:body][:action]
10: @data = msg[:body][:data]
11: @sender = msg[:senderid]
12: @agent = msg[:body][:agent]
13: @uniqid = msg[:requestid]
14: @caller = msg[:callerid] || "unknown"
15: end
If data is a hash, gives easy access to its members, else returns nil
# File lib/mcollective/rpc/request.rb, line 33
33: def [](key)
34: return nil unless @data.is_a?(Hash)
35: return @data[key]
36: end
If no :process_results is specified always respond else respond based on the supplied property
# File lib/mcollective/rpc/request.rb, line 26
26: def should_respond?
27: return @data[:process_results] if @data.include?(:process_results)
28:
29: return true
30: end
| Class | MCollective::RPC::Helpers |
| In: |
lib/mcollective/rpc/helpers.rb
|
| Parent: | Object |
Various utilities for the RPC system
Add SimpleRPC common options
# File lib/mcollective/rpc/helpers.rb, line 302
302: def self.add_simplerpc_options(parser, options)
303: parser.separator ""
304:
305: # add SimpleRPC specific options to all clients that use our library
306: parser.on('--np', '--no-progress', 'Do not show the progress bar') do |v|
307: options[:progress_bar] = false
308: end
309:
310: parser.on('--one', '-1', 'Send request to only one discovered nodes') do |v|
311: options[:mcollective_limit_targets] = 1
312: end
313:
314: parser.on('--batch SIZE', Integer, 'Do requests in batches') do |v|
315: options[:batch_size] = v
316: end
317:
318: parser.on('--batch-sleep SECONDS', Float, 'Sleep time between batches') do |v|
319: options[:batch_sleep_time] = v
320: end
321:
322: parser.on('--limit-nodes COUNT', '--ln', 'Send request to only a subset of nodes, can be a percentage') do |v|
323: raise "Invalid limit specified: #{v} valid limits are /^\d+%*$/" unless v =~ /^\d+%*$/
324:
325: if v =~ /^\d+$/
326: options[:mcollective_limit_targets] = v.to_i
327: else
328: options[:mcollective_limit_targets] = v
329: end
330: end
331:
332: parser.on('--json', '-j', 'Produce JSON output') do |v|
333: options[:progress_bar] = false
334: options[:output_format] = :json
335: end
336: end
Return color codes, if the config color= option is false just return a empty string
# File lib/mcollective/rpc/helpers.rb, line 71
71: def self.color(code)
72: colorize = Config.instance.color
73:
74: colors = {:red => "[31m",
75: :green => "[32m",
76: :yellow => "[33m",
77: :cyan => "[36m",
78: :bold => "[1m",
79: :reset => "[0m"}
80:
81: if colorize
82: return colors[code] || ""
83: else
84: return ""
85: end
86: end
Checks in PATH returns true if the command is found
# File lib/mcollective/rpc/helpers.rb, line 6
6: def self.command_in_path?(command)
7: found = ENV["PATH"].split(File::PATH_SEPARATOR).map do |p|
8: File.exist?(File.join(p, command))
9: end
10:
11: found.include?(true)
12: end
Given an array of something, make sure each is a string chomp off any new lines and return just the array of hosts
# File lib/mcollective/rpc/helpers.rb, line 38
38: def self.extract_hosts_from_array(hosts)
39: [hosts].flatten.map do |host|
40: raise "#{host} should be a string" unless host.is_a?(String)
41: host.chomp
42: end
43: end
Parse JSON output as produced by printrpc and extract the "sender" of each rpc response
The simplist valid JSON based data would be:
[
{"sender" => "example.com"},
{"sender" => "another.com"}
]
# File lib/mcollective/rpc/helpers.rb, line 23
23: def self.extract_hosts_from_json(json)
24: hosts = JSON.parse(json)
25:
26: raise "JSON hosts list is not an array" unless hosts.is_a?(Array)
27:
28: hosts.map do |host|
29: raise "JSON host list is not an array of Hashes" unless host.is_a?(Hash)
30: raise "JSON host list does not have senders in it" unless host.include?("sender")
31:
32: host["sender"]
33: end.uniq
34: end
Backward compatible display block for results without a DDL
# File lib/mcollective/rpc/helpers.rb, line 250
250: def self.old_rpcresults(result, flags = {})
251: result_text = ""
252:
253: if flags[:flatten]
254: result.each do |r|
255: if r[:statuscode] <= 1
256: data = r[:data]
257:
258: unless data.is_a?(String)
259: result_text << data.pretty_inspect
260: else
261: result_text << data
262: end
263: else
264: result_text << r.pretty_inspect
265: end
266: end
267:
268: result_text << ""
269: else
270: [result].flatten.each do |r|
271:
272: if flags[:verbose]
273: result_text << "%-40s: %s\n" % [r[:sender], r[:statusmsg]]
274:
275: if r[:statuscode] <= 1
276: r[:data].pretty_inspect.split("\n").each {|m| result_text += " #{m}"}
277: result_text << "\n\n"
278: elsif r[:statuscode] == 2
279: # dont print anything, no useful data to display
280: # past what was already shown
281: elsif r[:statuscode] == 3
282: # dont print anything, no useful data to display
283: # past what was already shown
284: elsif r[:statuscode] == 4
285: # dont print anything, no useful data to display
286: # past what was already shown
287: else
288: result_text << " #{r[:statusmsg]}"
289: end
290: else
291: unless r[:statuscode] == 0
292: result_text << "%-40s %s\n" % [r[:sender], colorize(:red, r[:statusmsg])]
293: end
294: end
295: end
296: end
297:
298: result_text << ""
299: end
Returns a blob of text representing the results in a standard way
It tries hard to do sane things so you often should not need to write your own display functions
If the agent you are getting results for has a DDL it will use the hints in there to do the right thing specifically it will look at the values of display in the DDL to choose when to show results
If you do not have a DDL you can pass these flags:
printrpc exim.mailq, :flatten => true printrpc exim.mailq, :verbose => true
If you‘ve asked it to flatten the result it will not print sender hostnames, it will just print the result as if it‘s one huge result, handy for things like showing a combined mailq.
# File lib/mcollective/rpc/helpers.rb, line 111
111: def self.rpcresults(result, flags = {})
112: flags = {:verbose => false, :flatten => false, :format => :console}.merge(flags)
113:
114: result_text = ""
115: ddl = nil
116:
117: # if running in verbose mode, just use the old style print
118: # no need for all the DDL helpers obfuscating the result
119: if flags[:format] == :json
120: if STDOUT.tty?
121: result_text = JSON.pretty_generate(result)
122: else
123: result_text = result.to_json
124: end
125: else
126: if flags[:verbose]
127: result_text = old_rpcresults(result, flags)
128: else
129: [result].flatten.each do |r|
130: begin
131: ddl ||= DDL.new(r.agent).action_interface(r.action.to_s)
132:
133: sender = r[:sender]
134: status = r[:statuscode]
135: message = r[:statusmsg]
136: display = ddl[:display]
137: result = r[:data]
138:
139: # appand the results only according to what the DDL says
140: case display
141: when :ok
142: if status == 0
143: result_text << text_for_result(sender, status, message, result, ddl)
144: end
145:
146: when :failed
147: if status > 0
148: result_text << text_for_result(sender, status, message, result, ddl)
149: end
150:
151: when :always
152: result_text << text_for_result(sender, status, message, result, ddl)
153:
154: when :flatten
155: result_text << text_for_flattened_result(status, result)
156:
157: end
158: rescue Exception => e
159: # no DDL so just do the old style print unchanged for
160: # backward compat
161: result_text = old_rpcresults(result, flags)
162: end
163: end
164: end
165: end
166:
167: result_text
168: end
Figures out the columns and liens of the current tty
Returns [0, 0] if it can‘t figure it out or if you‘re not running on a tty
# File lib/mcollective/rpc/helpers.rb, line 49
49: def self.terminal_dimensions
50: return [0, 0] unless STDOUT.tty?
51:
52: return [80, 40] if Util.windows?
53:
54: if ENV["COLUMNS"] && ENV["LINES"]
55: return [ENV["COLUMNS"].to_i, ENV["LINES"].to_i]
56:
57: elsif ENV["TERM"] && command_in_path?("tput")
58: return [`tput cols`.to_i, `tput lines`.to_i]
59:
60: elsif command_in_path?('stty')
61: return `stty size`.scan(/\d+/).map {|s| s.to_i }
62: else
63: return [0, 0]
64: end
65: rescue
66: [0, 0]
67: end
Returns text representing a flattened result of only good data
# File lib/mcollective/rpc/helpers.rb, line 237
237: def self.text_for_flattened_result(status, result)
238: result_text = ""
239:
240: if status <= 1
241: unless result.is_a?(String)
242: result_text << result.pretty_inspect
243: else
244: result_text << result
245: end
246: end
247: end
Return text representing a result
# File lib/mcollective/rpc/helpers.rb, line 171
171: def self.text_for_result(sender, status, msg, result, ddl)
172: statusses = ["",
173: colorize(:red, "Request Aborted"),
174: colorize(:yellow, "Unknown Action"),
175: colorize(:yellow, "Missing Request Data"),
176: colorize(:yellow, "Invalid Request Data"),
177: colorize(:red, "Unknown Request Status")]
178:
179: result_text = "%-40s %s\n" % [sender, statusses[status]]
180: result_text << " %s\n" % [colorize(:yellow, msg)] unless msg == "OK"
181:
182: # only print good data, ignore data that results from failure
183: if [0, 1].include?(status)
184: if result.is_a?(Hash)
185: # figure out the lengths of the display as strings, we'll use
186: # it later to correctly justify the output
187: lengths = result.keys.map do |k|
188: begin
189: ddl[:output][k][:display_as].size
190: rescue
191: k.to_s.size
192: end
193: end
194:
195: result.keys.each do |k|
196: # get all the output fields nicely lined up with a
197: # 3 space front padding
198: begin
199: display_as = ddl[:output][k][:display_as]
200: rescue
201: display_as = k.to_s
202: end
203:
204: display_length = display_as.size
205: padding = lengths.max - display_length + 3
206: result_text << " " * padding
207:
208: result_text << "#{display_as}:"
209:
210: if [String, Numeric].include?(result[k].class)
211: lines = result[k].to_s.split("\n")
212:
213: if lines.empty?
214: result_text << "\n"
215: else
216: lines.each_with_index do |line, i|
217: i == 0 ? padtxt = " " : padtxt = " " * (padding + display_length + 2)
218:
219: result_text << "#{padtxt}#{line}\n"
220: end
221: end
222: else
223: padding = " " * (lengths.max + 5)
224: result_text << " " << result[k].pretty_inspect.split("\n").join("\n" << padding) << "\n"
225: end
226: end
227: else
228: result_text << "\n\t" + result.pretty_inspect.split("\n").join("\n\t")
229: end
230: end
231:
232: result_text << "\n"
233: result_text
234: end
| Class | MCollective::RPC::Progress |
| In: |
lib/mcollective/rpc/progress.rb
|
| Parent: | Object |
Class that shows a progress bar, currently only supports a twirling progress bar.
You can specify a size for the progress bar if you want if you dont it will use the helper functions to figure out terminal dimensions and draw an appropriately sized bar
p = Progress.new 100.times {|i| print p.twirl(i+1, 100) + "\r"};puts
* [ ==================================================> ] 100 / 100
# File lib/mcollective/rpc/progress.rb, line 15
15: def initialize(size=nil)
16: @twirl = ['|', '/', '-', "\\", '|', '/', '-', "\\"]
17: @twirldex = 0
18:
19: if size
20: @size = size
21: else
22: cols = Helpers.terminal_dimensions[0] - 22
23:
24: # Defaults back to old behavior if it
25: # couldn't figure out the size or if
26: # its more than 60 wide
27: if cols <= 0
28: @size = 0
29: elsif cols > 60
30: @size = 60
31: else
32: @size = cols
33: end
34: end
35: end
# File lib/mcollective/rpc/progress.rb, line 37
37: def twirl(current, total)
38: # if the size is negative there is just not enough
39: # space on the terminal, return a simpler version
40: return "\r#{current} / #{total}" if @size == 0
41:
42: if current == total
43: txt = "\r " + Helpers.colorize(:green, "*") + " [ "
44: else
45: txt = "\r #{@twirl[@twirldex]} [ "
46: end
47:
48: dashes = ((current.to_f / total) * @size).round
49:
50: dashes.times { txt << "=" }
51: txt << ">"
52:
53: (@size - dashes).times { txt << " " }
54:
55: txt << " ] #{current} / #{total}"
56:
57: @twirldex == 7 ? @twirldex = 0 : @twirldex += 1
58:
59: return txt
60: end
| Class | MCollective::RPC::DDL |
| In: |
lib/mcollective/rpc/ddl.rb
|
| Parent: | Object |
A class that helps creating data description language files for agents. You can define meta data, actions, input and output describing the behavior of your agent.
Later you can access this information to assist with creating of user interfaces or online help
A sample DDL can be seen below, you‘d put this in your agent dir as <agent name>.ddl
metadata :name => "SimpleRPC Service Agent",
:description => "Agent to manage services using the Puppet service provider",
:author => "R.I.Pienaar",
:license => "GPLv2",
:version => "1.1",
:url => "http://mcollective-plugins.googlecode.com/",
:timeout => 60
action "status", :description => "Gets the status of a service" do
display :always
input "service",
:prompt => "Service Name",
:description => "The service to get the status for",
:type => :string,
:validation => '^[a-zA-Z\-_\d]+$',
:optional => true,
:maxlength => 30
output "status",
:description => "The status of service",
:display_as => "Service Status"
end
| meta | [R] |
# File lib/mcollective/rpc/ddl.rb, line 39
39: def initialize(agent, loadddl=true)
40: @actions = {}
41: @meta = {}
42: @config = MCollective::Config.instance
43: @agent = agent
44:
45: if loadddl
46: if ddlfile = findddlfile(agent)
47: instance_eval(File.read(ddlfile))
48: else
49: raise("Can't find DDL for agent '#{agent}'")
50: end
51: end
52: end
Creates the definition for an action, you can nest input definitions inside the action to attach inputs and validation to the actions
action "status", :description => "Restarts a Service" do
display :always
input "service",
:prompt => "Service Action",
:description => "The action to perform",
:type => :list,
:optional => true,
:list => ["start", "stop", "restart", "status"]
output "status"
:description => "The status of the service after the action"
end
# File lib/mcollective/rpc/ddl.rb, line 92
92: def action(name, input, &block)
93: raise "Action needs a :description" unless input.include?(:description)
94:
95: unless @actions.include?(name)
96: @actions[name] = {}
97: @actions[name][:action] = name
98: @actions[name][:input] = {}
99: @actions[name][:output] = {}
100: @actions[name][:display] = :failed
101: @actions[name][:description] = input[:description]
102: end
103:
104: # if a block is passed it might be creating input methods, call it
105: # we set @current_action so the input block can know what its talking
106: # to, this is probably an epic hack, need to improve.
107: @current_action = name
108: block.call if block_given?
109: @current_action = nil
110: end
Sets the display preference to either :ok, :failed, :flatten or :always operates on action level
# File lib/mcollective/rpc/ddl.rb, line 160
160: def display(pref)
161: # defaults to old behavior, complain if its supplied and invalid
162: unless [:ok, :failed, :flatten, :always].include?(pref)
163: raise "Display preference #{pref} is not valid, should be :ok, :failed, :flatten or :always"
164: end
165:
166: action = @current_action
167: @actions[action][:display] = pref
168: end
# File lib/mcollective/rpc/ddl.rb, line 54
54: def findddlfile(agent)
55: @config.libdir.each do |libdir|
56: ddlfile = File.join([libdir, "mcollective", "agent", "#{agent}.ddl"])
57:
58: if File.exist?(ddlfile)
59: Log.debug("Found #{agent} ddl at #{ddlfile}")
60: return ddlfile
61: end
62: end
63: return false
64: end
Generates help using the template based on the data created with metadata and input
# File lib/mcollective/rpc/ddl.rb, line 172
172: def help(template)
173: template = IO.read(template)
174: meta = @meta
175: actions = @actions
176:
177: erb = ERB.new(template, 0, '%')
178: erb.result(binding)
179: end
Registers an input argument for a given action
See the documentation for action for how to use this
# File lib/mcollective/rpc/ddl.rb, line 115
115: def input(argument, properties)
116: raise "Cannot figure out what action input #{argument} belongs to" unless @current_action
117:
118: action = @current_action
119:
120: [:prompt, :description, :type, :optional].each do |arg|
121: raise "Input needs a :#{arg}" unless properties.include?(arg)
122: end
123:
124: @actions[action][:input][argument] = {:prompt => properties[:prompt],
125: :description => properties[:description],
126: :type => properties[:type],
127: :optional => properties[:optional]}
128:
129: case properties[:type]
130: when :string
131: raise "Input type :string needs a :validation argument" unless properties.include?(:validation)
132: raise "Input type :string needs a :maxlength argument" unless properties.include?(:maxlength)
133:
134: @actions[action][:input][argument][:validation] = properties[:validation]
135: @actions[action][:input][argument][:maxlength] = properties[:maxlength]
136:
137: when :list
138: raise "Input type :list needs a :list argument" unless properties.include?(:list)
139:
140: @actions[action][:input][argument][:list] = properties[:list]
141: end
142: end
Registers meta data for the introspection hash
# File lib/mcollective/rpc/ddl.rb, line 67
67: def metadata(meta)
68: [:name, :description, :author, :license, :version, :url, :timeout].each do |arg|
69: raise "Metadata needs a :#{arg}" unless meta.include?(arg)
70: end
71:
72: @meta = meta
73: end
Registers an output argument for a given action
See the documentation for action for how to use this
# File lib/mcollective/rpc/ddl.rb, line 147
147: def output(argument, properties)
148: raise "Cannot figure out what action input #{argument} belongs to" unless @current_action
149: raise "Output #{argument} needs a description argument" unless properties.include?(:description)
150: raise "Output #{argument} needs a display_as argument" unless properties.include?(:display_as)
151:
152: action = @current_action
153:
154: @actions[action][:output][argument] = {:description => properties[:description],
155: :display_as => properties[:display_as]}
156: end
Helper to use the DDL to figure out if the remote call should be allowed based on action name and inputs.
# File lib/mcollective/rpc/ddl.rb, line 193
193: def validate_request(action, arguments)
194: # is the action known?
195: unless actions.include?(action)
196: raise DDLValidationError, "Attempted to call action #{action} for #{@agent} but it's not declared in the DDL"
197: end
198:
199: input = action_interface(action)[:input]
200:
201: input.keys.each do |key|
202: unless input[key][:optional]
203: unless arguments.keys.include?(key)
204: raise DDLValidationError, "Action #{action} needs a #{key} argument"
205: end
206: end
207:
208: # validate strings, lists and booleans, we'll add more types of validators when
209: # all the use cases are clear
210: #
211: # only does validation for arguments actually given, since some might
212: # be optional. We validate the presense of the argument earlier so
213: # this is a safe assumption, just to skip them.
214: #
215: # :string can have maxlength and regex. A maxlength of 0 will bypasss checks
216: # :list has a array of valid values
217: if arguments.keys.include?(key)
218: case input[key][:type]
219: when :string
220: raise DDLValidationError, "Input #{key} should be a string" unless arguments[key].is_a?(String)
221:
222: if input[key][:maxlength].to_i > 0
223: if arguments[key].size > input[key][:maxlength].to_i
224: raise DDLValidationError, "Input #{key} is longer than #{input[key][:maxlength]} character(s)"
225: end
226: end
227:
228: unless arguments[key].match(Regexp.new(input[key][:validation]))
229: raise DDLValidationError, "Input #{key} does not match validation regex #{input[key][:validation]}"
230: end
231:
232: when :list
233: unless input[key][:list].include?(arguments[key])
234: raise DDLValidationError, "Input #{key} doesn't match list #{input[key][:list].join(', ')}"
235: end
236:
237: when :boolean
238: unless [TrueClass, FalseClass].include?(arguments[key].class)
239: raise DDLValidationError, "Input #{key} should be a boolean"
240: end
241:
242: when :integer
243: raise DDLValidationError, "Input #{key} should be a integer" unless arguments[key].is_a?(Fixnum)
244:
245: when :float
246: raise DDLValidationError, "Input #{key} should be a floating point number" unless arguments[key].is_a?(Float)
247:
248: when :number
249: raise DDLValidationError, "Input #{key} should be a number" unless arguments[key].is_a?(Numeric)
250: end
251: end
252: end
253:
254: true
255: end
| Class | MCollective::RPC::Stats |
| In: |
lib/mcollective/rpc/stats.rb
|
| Parent: | Object |
Class to wrap all the stats and to keep track of some timings
| blocktime | [RW] | |
| discovered | [RW] | |
| discovered_nodes | [RW] | |
| discoverytime | [RW] | |
| failcount | [RW] | |
| noresponsefrom | [RW] | |
| noresponsefrom | [RW] | |
| okcount | [RW] | |
| responses | [RW] | |
| responsesfrom | [RW] | |
| starttime | [RW] | |
| totaltime | [RW] |
Fake hash access to keep things backward compatible
# File lib/mcollective/rpc/stats.rb, line 44
44: def [](key)
45: to_hash[key]
46: rescue
47: nil
48: end
Re-initializes the object with stats from the basic client
# File lib/mcollective/rpc/stats.rb, line 65
65: def client_stats=(stats)
66: @noresponsefrom = stats[:noresponsefrom]
67: @responses = stats[:responses]
68: @starttime = stats[:starttime]
69: @blocktime = stats[:blocktime]
70: @totaltime = stats[:totaltime]
71: @discoverytime = stats[:discoverytime] if @discoverytime == 0
72: end
Update discovered and discovered_nodes based on discovery results
# File lib/mcollective/rpc/stats.rb, line 102
102: def discovered_agents(agents)
103: @discovered_nodes = agents
104: @discovered = agents.size
105: end
increment the count of failed hosts
# File lib/mcollective/rpc/stats.rb, line 58
58: def fail
59: @failcount += 1
60: rescue
61: @failcount = 1
62: end
Helper to calculate total time etc
# File lib/mcollective/rpc/stats.rb, line 108
108: def finish_request
109: @totaltime = @blocktime + @discoverytime
110:
111: # figures out who we had no responses from
112: dhosts = @discovered_nodes.clone
113: @responsesfrom.each {|r| dhosts.delete(r)}
114: @noresponsefrom = dhosts
115: rescue
116: @totaltime = 0
117: @noresponsefrom = []
118: end
Returns a blob of text indicating what nodes did not respond
# File lib/mcollective/rpc/stats.rb, line 167
167: def no_response_report
168: result_text = []
169:
170: if @noresponsefrom.size > 0
171: result_text << Helpers.colorize(:red, "\nNo response from:\n")
172:
173: @noresponsefrom.each_with_index do |c,i|
174: result_text << "" if i % 4 == 0
175: result_text << "%30s" % [c]
176: end
177:
178: result_text << ""
179: end
180:
181: result_text.join("\n")
182: end
Helper to keep track of who we received responses from
# File lib/mcollective/rpc/stats.rb, line 121
121: def node_responded(node)
122: @responsesfrom << node
123: rescue
124: @responsesfrom = [node]
125: end
Returns a blob of text representing the request status based on the stats contained in this class
# File lib/mcollective/rpc/stats.rb, line 129
129: def report(caption = "rpc stats", verbose = false)
130: result_text = []
131:
132: if verbose
133: result_text << Helpers.colorize(:yellow, "---- #{caption} ----")
134:
135: if @discovered
136: @responses < @discovered ? color = :red : color = :reset
137: result_text << " Nodes: %s / %s" % [ Helpers.colorize(color, @discovered), Helpers.colorize(color, @responses) ]
138: else
139: result_text << " Nodes: #{@responses}"
140: end
141:
142: @failcount < 0 ? color = :red : color = :reset
143:
144: result_text << " Pass / Fail: %s / %s" % [Helpers.colorize(color, @okcount), Helpers.colorize(color, @failcount) ]
145: result_text << " Start Time: %s" % [Time.at(@starttime)]
146: result_text << " Discovery Time: %.2fms" % [@discoverytime * 1000]
147: result_text << " Agent Time: %.2fms" % [@blocktime * 1000]
148: result_text << " Total Time: %.2fms" % [@totaltime * 1000]
149: else
150: if @discovered
151: @responses < @discovered ? color = :red : color = :green
152:
153: result_text << "Finished processing %s / %s hosts in %.2f ms" % [Helpers.colorize(color, @responses), Helpers.colorize(color, @discovered), @blocktime * 1000]
154: else
155: result_text << "Finished processing %s hosts in %.2f ms" % [Helpers.colorize(:bold, @responses), @blocktime * 1000]
156: end
157: end
158:
159: if no_response_report != ""
160: result_text << "" << no_response_report
161: end
162:
163: result_text.join("\n")
164: end
Resets stats, if discovery time is set we keep it as it was
# File lib/mcollective/rpc/stats.rb, line 13
13: def reset
14: @noresponsefrom = []
15: @responsesfrom = []
16: @responses = 0
17: @starttime = Time.now.to_f
18: @discoverytime = 0 unless @discoverytime
19: @blocktime = 0
20: @totaltime = 0
21: @discovered = 0
22: @discovered_nodes = []
23: @okcount = 0
24: @failcount = 0
25: @noresponsefrom = []
26: end
helper to time block execution time
# File lib/mcollective/rpc/stats.rb, line 88
88: def time_block_execution(action)
89: if action == :start
90: @block_start = Time.now.to_f
91: elsif action == :end
92: @blocktime += Time.now.to_f - @block_start
93: else
94: raise("Uknown block action #{action}")
95: end
96: rescue
97: @blocktime = 0
98: end
Utility to time discovery from :start to :end
# File lib/mcollective/rpc/stats.rb, line 75
75: def time_discovery(action)
76: if action == :start
77: @discovery_start = Time.now.to_f
78: elsif action == :end
79: @discoverytime = Time.now.to_f - @discovery_start
80: else
81: raise("Uknown discovery action #{action}")
82: end
83: rescue
84: @discoverytime = 0
85: end
returns a hash of our stats
# File lib/mcollective/rpc/stats.rb, line 29
29: def to_hash
30: {:noresponsefrom => @noresponsefrom,
31: :starttime => @starttime,
32: :discoverytime => @discoverytime,
33: :blocktime => @blocktime,
34: :responses => @responses,
35: :totaltime => @totaltime,
36: :discovered => @discovered,
37: :discovered_nodes => @discovered_nodes,
38: :noresponsefrom => @noresponsefrom,
39: :okcount => @okcount,
40: :failcount => @failcount}
41: end
| Module | MCollective::Security |
| In: |
lib/mcollective/security/base.rb
lib/mcollective/security.rb |
Security is implimented using a module structure and installations can configure which module they want to use.
Security modules deal with various aspects of authentication and authorization:
To impliment a new security class using SSL for example you would inherit from the base class and only impliment:
Each of these methods should increment various stats counters, see the default MCollective::Security::Psk module for examples of this
Filtering can be extended by providing a new validate_filter? method.
| Class | MCollective::Shell |
| In: |
lib/mcollective/shell.rb
|
| Parent: | Object |
Wrapper around systemu that handles executing of system commands in a way that makes stdout, stderr and status available. Supports timeouts and sets a default sane environment.
s = Shell.new("date", opts)
s.runcommand
puts s.stdout
puts s.stderr
puts s.status.exitcode
Options hash can have:
cwd - the working directory the command will be run from
stdin - a string that will be sent to stdin of the program
stdout - a variable that will receive stdout, must support <<
stderr - a variable that will receive stdin, must support <<
environment - the shell environment, defaults to include LC_ALL=C
set to nil to clear the environment even of LC_ALL
| command | [R] | |
| cwd | [R] | |
| environment | [R] | |
| status | [R] | |
| stderr | [R] | |
| stdin | [R] | |
| stdout | [R] |
# File lib/mcollective/shell.rb, line 24
24: def initialize(command, options={})
25: @environment = {"LC_ALL" => "C"}
26: @command = command
27: @status = nil
28: @stdout = ""
29: @stderr = ""
30: @stdin = nil
31: @cwd = Dir.tmpdir
32:
33: options.each do |opt, val|
34: case opt.to_s
35: when "stdout"
36: raise "stdout should support <<" unless val.respond_to?("<<")
37: @stdout = val
38:
39: when "stderr"
40: raise "stderr should support <<" unless val.respond_to?("<<")
41: @stderr = val
42:
43: when "stdin"
44: raise "stdin should be a String" unless val.is_a?(String)
45: @stdin = val
46:
47: when "cwd"
48: raise "Directory #{val} does not exist" unless File.directory?(val)
49: @cwd = val
50:
51: when "environment"
52: if val.nil?
53: @environment = {}
54: else
55: @environment.merge!(val.dup)
56: end
57: end
58: end
59: end
Actually does the systemu call passing in the correct environment, stdout and stderr
# File lib/mcollective/shell.rb, line 62
62: def runcommand
63: opts = {"env" => @environment,
64: "stdout" => @stdout,
65: "stderr" => @stderr,
66: "cwd" => @cwd}
67:
68: opts["stdin"] = @stdin if @stdin
69:
70: # Running waitpid on the cid here will start a thread
71: # with the waitpid in it, this way even if the thread
72: # that started this process gets killed due to agent
73: # timeout or such there will still be a waitpid waiting
74: # for the child to exit and not leave zombies.
75: @status = systemu(@command, opts) do |cid|
76: begin
77: sleep 1
78: Process::waitpid(cid)
79: rescue SystemExit
80: rescue Errno::ECHILD
81: rescue Exception => e
82: Log.info("Unexpected exception received while waiting for child process: #{e.class}: #{e}")
83: end
84: end
85: end
| Class | MCollective::Facts::Base |
| In: |
lib/mcollective/facts/base.rb
|
| Parent: | Object |
A base class for fact providers, to make a new fully functional fact provider inherit from this and simply provide a self.get_facts method that returns a hash like:
{"foo" => "bar",
"bar" => "baz"}
# File lib/mcollective/facts/base.rb, line 10
10: def initialize
11: @facts = {}
12: @last_good_facts = {}
13: @last_facts_load = 0
14: end
Plugins can override this to provide forced fact invalidation
# File lib/mcollective/facts/base.rb, line 81
81: def force_reload?
82: false
83: end
Returns the value of a single fact
# File lib/mcollective/facts/base.rb, line 22
22: def get_fact(fact=nil)
23: config = Config.instance
24:
25: cache_time = config.fact_cache_time || 300
26:
27: Thread.exclusive do
28: begin
29: if (Time.now.to_i - @last_facts_load > cache_time.to_i ) || force_reload?
30: Log.debug("Resetting facter cache, now: #{Time.now.to_i} last-known-good: #{@last_facts_load}")
31:
32: tfacts = load_facts_from_source
33:
34: # Force reset to last known good state on empty facts
35: raise "Got empty facts" if tfacts.empty?
36:
37: @facts.clear
38:
39: tfacts.each_pair do |key,value|
40: @facts[key.to_s] = value.to_s
41: end
42:
43: @last_good_facts = @facts.clone
44: @last_facts_load = Time.now.to_i
45: else
46: Log.debug("Using cached facts now: #{Time.now.to_i} last-known-good: #{@last_facts_load}")
47: end
48: rescue Exception => e
49: Log.error("Failed to load facts: #{e.class}: #{e}")
50:
51: # Avoid loops where failing fact loads cause huge CPU
52: # loops, this way it only retries once every cache_time
53: # seconds
54: @last_facts_load = Time.now.to_i
55:
56: # Revert to last known good state
57: @facts = @last_good_facts.clone
58: end
59: end
60:
61:
62: # If you do not supply a specific fact all facts will be returned
63: if fact.nil?
64: return @facts
65: else
66: @facts.include?(fact) ? @facts[fact] : nil
67: end
68: end
Returns all facts
# File lib/mcollective/facts/base.rb, line 71
71: def get_facts
72: get_fact(nil)
73: end
| Module | MCollective::PluginPackager |
| In: |
lib/mcollective/pluginpackager.rb
lib/mcollective/pluginpackager/standard_definition.rb lib/mcollective/pluginpackager/agent_definition.rb |
# File lib/mcollective/pluginpackager.rb, line 12
12: def self.[](klass)
13: const_get("#{klass}")
14: end
Checks if a build tool is present on the system
# File lib/mcollective/pluginpackager.rb, line 47
47: def self.build_tool?(build_tool)
48: ENV["PATH"].split(File::PATH_SEPARATOR).each do |path|
49: builder = File.join(path, build_tool)
50: if File.exists?(builder)
51: return true
52: end
53: end
54: false
55: end
Checks if a directory is present and not empty
# File lib/mcollective/pluginpackager.rb, line 24
24: def self.check_dir_present(path)
25: (File.directory?(path) && !Dir.glob(File.join(path, "*")).empty?)
26: end
Quietly calls a block if verbose parameter is false
# File lib/mcollective/pluginpackager.rb, line 29
29: def self.do_quietly?(verbose, &block)
30: unless verbose
31: old_stdout = $stdout.clone
32: $stdout.reopen(File.new("/dev/null", "w"))
33: begin
34: block.call
35: rescue Exception => e
36: $stdout.reopen old_stdout
37: raise e
38: ensure
39: $stdout.reopen old_stdout
40: end
41: else
42: block.call
43: end
44: end
Fetch and return metadata from plugin DDL
# File lib/mcollective/pluginpackager.rb, line 17
17: def self.get_metadata(path, type)
18: ddl = MCollective::RPC::DDL.new("package", false)
19: ddl.instance_eval File.read(Dir.glob(File.join(path, type, "*.ddl")).first)
20: ddl.meta
21: end
Package implementation plugins
# File lib/mcollective/pluginpackager.rb, line 8
8: def self.load_packagers
9: PluginManager.find_and_load("pluginpackager")
10: end
| Class | MCollective::Client |
| In: |
lib/mcollective/client.rb
|
| Parent: | Object |
Helpers for writing clients that can talk to agents, do discovery and so forth
| options | [RW] | |
| stats | [RW] |
# File lib/mcollective/client.rb, line 6
6: def initialize(configfile)
7: @config = Config.instance
8: @config.loadconfig(configfile) unless @config.configured
9:
10: @connection = PluginManager["connector_plugin"]
11: @security = PluginManager["security_plugin"]
12:
13: @security.initiated_by = :client
14: @options = nil
15: @subscriptions = {}
16:
17: @connection.connect
18: end
Returns the configured main collective if no specific collective is specified as options
# File lib/mcollective/client.rb, line 22
22: def collective
23: if @options[:collective].nil?
24: @config.main_collective
25: else
26: @options[:collective]
27: end
28: end
Disconnects cleanly from the middleware
# File lib/mcollective/client.rb, line 31
31: def disconnect
32: Log.debug("Disconnecting from the middleware")
33: @connection.disconnect
34: end
Performs a discovery of nodes matching the filter passed returns an array of nodes
An integer limit can be supplied this will have the effect of the discovery being cancelled soon as it reached the requested limit of hosts
# File lib/mcollective/client.rb, line 114
114: def discover(filter, timeout, limit=0)
115: raise "Limit has to be an integer" unless limit.is_a?(Fixnum)
116:
117: begin
118: hosts = []
119: Timeout.timeout(timeout) do
120: reqid = sendreq("ping", "discovery", filter)
121: Log.debug("Waiting #{timeout} seconds for discovery replies to request #{reqid}")
122:
123: loop do
124: reply = receive(reqid)
125: Log.debug("Got discovery reply from #{reply.payload[:senderid]}")
126: hosts << reply.payload[:senderid]
127:
128: return hosts if limit > 0 && hosts.size == limit
129: end
130: end
131: rescue Timeout::Error => e
132: rescue Exception => e
133: raise
134: ensure
135: unsubscribe("discovery", :reply)
136: end
137:
138: hosts.sort
139: end
Performs a discovery and then send a request, performs the passed block for each response
times = discovered_req("status", "mcollectived", options, client) {|resp|
pp resp
}
It returns a hash of times and timeouts for discovery and total run is taken from the options hash which in turn is generally built using MCollective::Optionparser
# File lib/mcollective/client.rb, line 201
201: def discovered_req(body, agent, options=false)
202: stat = {:starttime => Time.now.to_f, :discoverytime => 0, :blocktime => 0, :totaltime => 0}
203:
204: options = @options unless options
205:
206: STDOUT.sync = true
207:
208: print("Determining the amount of hosts matching filter for #{options[:disctimeout]} seconds .... ")
209:
210: begin
211: discovered_hosts = discover(options[:filter], options[:disctimeout])
212: discovered = discovered_hosts.size
213: hosts_responded = []
214: hosts_not_responded = discovered_hosts
215:
216: stat[:discoverytime] = Time.now.to_f - stat[:starttime]
217:
218: puts("#{discovered}\n\n")
219: rescue Interrupt
220: puts("Discovery interrupted.")
221: exit!
222: end
223:
224: raise("No matching clients found") if discovered == 0
225:
226: begin
227: Timeout.timeout(options[:timeout]) do
228: reqid = sendreq(body, agent, options[:filter])
229:
230: (1..discovered).each do |c|
231: resp = receive(reqid)
232:
233: hosts_responded << resp.payload[:senderid]
234: hosts_not_responded.delete(resp.payload[:senderid]) if hosts_not_responded.include?(resp.payload[:senderid])
235:
236: yield(resp.payload)
237: end
238: end
239: rescue Interrupt => e
240: rescue Timeout::Error => e
241: end
242:
243: stat[:totaltime] = Time.now.to_f - stat[:starttime]
244: stat[:blocktime] = stat[:totaltime] - stat[:discoverytime]
245: stat[:responses] = hosts_responded.size
246: stat[:responsesfrom] = hosts_responded
247: stat[:noresponsefrom] = hosts_not_responded
248: stat[:discovered] = discovered
249:
250: @stats = stat
251: return stat
252: end
Prints out the stats returns from req and discovered_req in a nice way
# File lib/mcollective/client.rb, line 255
255: def display_stats(stats, options=false, caption="stomp call summary")
256: options = @options unless options
257:
258: if options[:verbose]
259: puts("\n---- #{caption} ----")
260:
261: if stats[:discovered]
262: puts(" Nodes: #{stats[:discovered]} / #{stats[:responses]}")
263: else
264: puts(" Nodes: #{stats[:responses]}")
265: end
266:
267: printf(" Start Time: %s\n", Time.at(stats[:starttime]))
268: printf(" Discovery Time: %.2fms\n", stats[:discoverytime] * 1000)
269: printf(" Agent Time: %.2fms\n", stats[:blocktime] * 1000)
270: printf(" Total Time: %.2fms\n", stats[:totaltime] * 1000)
271:
272: else
273: if stats[:discovered]
274: printf("\nFinished processing %d / %d hosts in %.2f ms\n\n", stats[:responses], stats[:discovered], stats[:blocktime] * 1000)
275: else
276: printf("\nFinished processing %d hosts in %.2f ms\n\n", stats[:responses], stats[:blocktime] * 1000)
277: end
278: end
279:
280: if stats[:noresponsefrom].size > 0
281: puts("\nNo response from:\n")
282:
283: stats[:noresponsefrom].each do |c|
284: puts if c % 4 == 1
285: printf("%30s", c)
286: end
287:
288: puts
289: end
290: end
Blocking call that waits for ever for a message to arrive.
If you give it a requestid this means you‘ve previously send a request with that ID and now you just want replies that matches that id, in that case the current connection will just ignore all messages not directed at it and keep waiting for more till it finds a matching message.
# File lib/mcollective/client.rb, line 84
84: def receive(requestid = nil)
85: reply = nil
86:
87: begin
88: reply = @connection.receive
89: reply.type = :reply
90: reply.expected_msgid = requestid
91:
92: reply.decode!
93:
94: reply.payload[:senderid] = Digest::MD5.hexdigest(reply.payload[:senderid]) if ENV.include?("MCOLLECTIVE_ANON")
95:
96: raise(MsgDoesNotMatchRequestID, "Message reqid #{requestid} does not match our reqid #{reply.requestid}") unless reply.requestid == requestid
97: rescue SecurityValidationFailed => e
98: Log.warn("Ignoring a message that did not pass security validations")
99: retry
100: rescue MsgDoesNotMatchRequestID => e
101: Log.debug("Ignoring a message for some other client")
102: retry
103: end
104:
105: reply
106: end
Send a request, performs the passed block for each response
times = req("status", "mcollectived", options, client) {|resp|
pp resp
}
It returns a hash of times and timeouts for discovery and total run is taken from the options hash which in turn is generally built using MCollective::Optionparser
# File lib/mcollective/client.rb, line 149
149: def req(body, agent=nil, options=false, waitfor=0)
150: if body.is_a?(Message)
151: agent = body.agent
152: options = body.options
153: waitfor = body.discovered_hosts.size || 0
154: end
155:
156: stat = {:starttime => Time.now.to_f, :discoverytime => 0, :blocktime => 0, :totaltime => 0}
157:
158: options = @options unless options
159:
160: STDOUT.sync = true
161:
162: hosts_responded = 0
163:
164: begin
165: Timeout.timeout(options[:timeout]) do
166: reqid = sendreq(body, agent, options[:filter])
167:
168: loop do
169: resp = receive(reqid)
170:
171: hosts_responded += 1
172:
173: yield(resp.payload)
174:
175: break if (waitfor != 0 && hosts_responded >= waitfor)
176: end
177: end
178: rescue Interrupt => e
179: rescue Timeout::Error => e
180: ensure
181: unsubscribe(agent, :reply)
182: end
183:
184: stat[:totaltime] = Time.now.to_f - stat[:starttime]
185: stat[:blocktime] = stat[:totaltime] - stat[:discoverytime]
186: stat[:responses] = hosts_responded
187: stat[:noresponsefrom] = []
188:
189: @stats = stat
190: return stat
191: end
Sends a request and returns the generated request id, doesn‘t wait for responses and doesn‘t execute any passed in code blocks for responses
# File lib/mcollective/client.rb, line 38
38: def sendreq(msg, agent, filter = {})
39: if msg.is_a?(Message)
40: request = msg
41: agent = request.agent
42: else
43: ttl = @options[:ttl] || @config.ttl
44: request = Message.new(msg, nil, {:agent => agent, :type => :request, :collective => collective, :filter => filter, :ttl => ttl})
45: request.reply_to = @options[:reply_to] if @options[:reply_to]
46: end
47:
48: request.encode!
49:
50: Log.debug("Sending request #{request.requestid} to the #{request.agent} agent with ttl #{request.ttl} in collective #{request.collective}")
51:
52: subscribe(agent, :reply)
53:
54: request.publish
55:
56: request.requestid
57: end
# File lib/mcollective/client.rb, line 59
59: def subscribe(agent, type)
60: unless @subscriptions.include?(agent)
61: subscription = Util.make_subscriptions(agent, type, collective)
62: Log.debug("Subscribing to #{type} target for agent #{agent}")
63:
64: Util.subscribe(subscription)
65: @subscriptions[agent] = 1
66: end
67: end
# File lib/mcollective/client.rb, line 69
69: def unsubscribe(agent, type)
70: if @subscriptions.include?(agent)
71: subscription = Util.make_subscriptions(agent, type, collective)
72: Log.debug("Unsubscribing #{type} target for #{agent}")
73:
74: Util.unsubscribe(subscription)
75: @subscriptions.delete(agent)
76: end
77: end
| Module | MCollective::Registration |
| In: |
lib/mcollective/registration.rb
lib/mcollective/registration/base.rb |
Registration is implimented using a module structure and installations can configure which module they want to use.
We provide a simple one that just sends back the list of current known agents in MCollective::Registration::Agentlist, you can create your own:
Create a module in plugins/mcollective/registration/<yourplugin>.rb
You can inherit from MCollective::Registration::Base in which case you just need to supply a body method, whatever this method returns will be send to the middleware connection for an agent called registration
| Class | MCollective::Log |
| In: |
lib/mcollective/log.rb
|
| Parent: | Object |
A simple class that allows logging at various levels.
configures the logger class, if the config has not yet been loaded we default to the console logging class and do not set @configured so that future calls to the log method will keep attempting to configure the logger till we eventually get a logging preference from the config module
# File lib/mcollective/log.rb, line 72
72: def configure(logger=nil)
73: unless logger
74: logger_type = "console"
75:
76: config = Config.instance
77:
78: if config.configured
79: logger_type = config.logger_type
80: @configured = true
81: end
82:
83: require "mcollective/logger/#{logger_type.downcase}_logger"
84: set_logger(eval("MCollective::Logger::#{logger_type.capitalize}_logger.new"))
85: else
86: set_logger(logger)
87: @configured = true
88: end
89:
90:
91: @logger.start
92: rescue Exception => e
93: @configured = false
94: STDERR.puts "Could not start logger: #{e.class} #{e}"
95: end
figures out the filename that called us
# File lib/mcollective/log.rb, line 98
98: def from
99: from = File.basename(caller[2])
100: end
handle old code that relied on this class being a singleton
# File lib/mcollective/log.rb, line 38
38: def instance
39: self
40: end
logs a message at a certain level
# File lib/mcollective/log.rb, line 48
48: def log(level, msg)
49: configure unless @configured
50:
51: raise "Unknown log level" unless [:error, :fatal, :debug, :warn, :info].include?(level)
52:
53: if @logger
54: @logger.log(level, from, msg)
55: else
56: t = Time.new.strftime("%H:%M:%S")
57:
58: STDERR.puts "#{t}: #{level}: #{from}: #{msg}"
59: end
60: end
| Class | MCollective::Registration::Base |
| In: |
lib/mcollective/registration/base.rb
|
| Parent: | Object |
This is a base class that other registration plugins can use to handle regular announcements to the mcollective
The configuration file determines how often registration messages gets sent using the registerinterval option, the plugin runs in the background in a thread.
Register plugins that inherits base
# File lib/mcollective/registration/base.rb, line 11
11: def self.inherited(klass)
12: PluginManager << {:type => "registration_plugin", :class => klass.to_s}
13: end
# File lib/mcollective/registration/base.rb, line 57
57: def interval
58: config.registerinterval
59: end
# File lib/mcollective/registration/base.rb, line 40
40: def msg_filter
41: {"agent" => "registration"}
42: end
# File lib/mcollective/registration/base.rb, line 61
61: def publish(message)
62: unless message
63: Log.debug("Skipping registration due to nil body")
64: else
65: req = Message.new(message, nil, {:type => :request, :agent => "registration", :collective => target_collective, :filter => msg_filter})
66: req.encode!
67:
68: Log.debug("Sending registration #{req.requestid} to collective #{req.collective}")
69:
70: req.publish
71: end
72: end
Creates a background thread that periodically send a registration notice.
The actual registration notices comes from the ‘body’ method of the registration plugins.
# File lib/mcollective/registration/base.rb, line 19
19: def run(connection)
20: return false if interval == 0
21:
22: Thread.new do
23: loop do
24: begin
25: publish(body)
26:
27: sleep interval
28: rescue Exception => e
29: Log.error("Sending registration message failed: #{e}")
30: sleep interval
31: end
32: end
33: end
34: end
# File lib/mcollective/registration/base.rb, line 44
44: def target_collective
45: main_collective = config.main_collective
46:
47: collective = config.registration_collective || main_collective
48:
49: unless config.collectives.include?(collective)
50: Log.warn("Sending registration to #{main_collective}: #{collective} is not a valid collective")
51: collective = main_collective
52: end
53:
54: return collective
55: end
| Class | MCollective::Application |
| In: |
lib/mcollective/application.rb
|
| Parent: | Object |
Sets the application description, there can be only one description per application so multiple calls will just change the description
# File lib/mcollective/application.rb, line 28
28: def description(descr)
29: self[:description] = descr
30: end
# File lib/mcollective/application.rb, line 38
38: def exclude_argument_sections(*sections)
39: sections = [sections].flatten
40:
41: sections.each do |s|
42: raise "Unknown CLI argument section #{s}" unless ["rpc", "common", "filter"].include?(s)
43: end
44:
45: intialize_application_options unless @application_options
46: self[:exclude_arg_sections] = sections
47: end
Wrapper to create command line options
- name: varaible name that will be used to access the option value
- description: textual info shown in --help
- arguments: a list of possible arguments that can be used
to activate this option
- type: a data type that ObjectParser understand of :bool or :array
- required: true or false if this option has to be supplied
- validate: a proc that will be called with the value used to validate
the supplied value
option :foo,
:description => "The foo option"
:arguments => ["--foo ARG"]
after this the value supplied will be in configuration[:foo]
# File lib/mcollective/application.rb, line 65
65: def option(name, arguments)
66: opt = {:name => name,
67: :description => nil,
68: :arguments => [],
69: :type => String,
70: :required => false,
71: :validate => Proc.new { true }}
72:
73: arguments.each_pair{|k,v| opt[k] = v}
74:
75: self[:cli_arguments] << opt
76: end
Returns an array of all the arguments built using calls to optin
# File lib/mcollective/application.rb, line 245
245: def application_cli_arguments
246: application_options[:cli_arguments]
247: end
Retrieve the current application description
# File lib/mcollective/application.rb, line 232
232: def application_description
233: application_options[:description]
234: end
Handles failure, if we‘re far enough in the initialization phase it will log backtraces if its in verbose mode only
# File lib/mcollective/application.rb, line 251
251: def application_failure(e, err_dest=STDERR)
252: # peole can use exit() anywhere and not get nasty backtraces as a result
253: if e.is_a?(SystemExit)
254: disconnect
255: raise(e)
256: end
257:
258: err_dest.puts "#{$0} failed to run: #{e} (#{e.class})"
259:
260: if options.nil? || options[:verbose]
261: e.backtrace.each{|l| err_dest.puts "\tfrom #{l}"}
262: end
263:
264: disconnect
265:
266: exit 1
267: end
Builds an ObjectParser config, parse the CLI options and validates based on the option config
# File lib/mcollective/application.rb, line 135
135: def application_parse_options(help=false)
136: @options ||= {:verbose => false}
137:
138: @options = clioptions(help) do |parser, options|
139: parser.define_head application_description if application_description
140: parser.banner = ""
141:
142: if application_usage
143: parser.separator ""
144:
145: application_usage.each do |u|
146: parser.separator "Usage: #{u}"
147: end
148:
149: parser.separator ""
150: end
151:
152: parser.define_tail ""
153: parser.define_tail "The Marionette Collective #{MCollective.version}"
154:
155:
156: application_cli_arguments.each do |carg|
157: opts_array = []
158:
159: opts_array << :on
160:
161: # if a default is set from the application set it up front
162: if carg.include?(:default)
163: configuration[carg[:name]] = carg[:default]
164: end
165:
166: # :arguments are multiple possible ones
167: if carg[:arguments].is_a?(Array)
168: carg[:arguments].each {|a| opts_array << a}
169: else
170: opts_array << carg[:arguments]
171: end
172:
173: # type was given and its not one of our special types, just pass it onto optparse
174: opts_array << carg[:type] if carg[:type] and ! [:bool, :array].include?(carg[:type])
175:
176: opts_array << carg[:description]
177:
178: # Handle our special types else just rely on the optparser to handle the types
179: if carg[:type] == :bool
180: parser.send(*opts_array) do |v|
181: validate_option(carg[:validate], carg[:name], v)
182:
183: configuration[carg[:name]] = true
184: end
185:
186: elsif carg[:type] == :array
187: parser.send(*opts_array) do |v|
188: validate_option(carg[:validate], carg[:name], v)
189:
190: configuration[carg[:name]] = [] unless configuration.include?(carg[:name])
191: configuration[carg[:name]] << v
192: end
193:
194: else
195: parser.send(*opts_array) do |v|
196: validate_option(carg[:validate], carg[:name], v)
197:
198: configuration[carg[:name]] = v
199: end
200: end
201: end
202: end
203: end
Creates a standard options hash, pass in a block to add extra headings etc see Optionparser
# File lib/mcollective/application.rb, line 111
111: def clioptions(help)
112: oparser = Optionparser.new({:verbose => false, :progress_bar => true}, "filter", application_options[:exclude_arg_sections])
113:
114: options = oparser.parse do |parser, options|
115: if block_given?
116: yield(parser, options)
117: end
118:
119: RPC::Helpers.add_simplerpc_options(parser, options) unless application_options[:exclude_arg_sections].include?("rpc")
120: end
121:
122: return oparser.parser.help if help
123:
124: validate_cli_options
125:
126: post_option_parser(configuration) if respond_to?(:post_option_parser)
127:
128: return options
129: rescue Exception => e
130: application_failure(e)
131: end
The application configuration built from CLI arguments
# File lib/mcollective/application.rb, line 88
88: def configuration
89: @application_configuration ||= {}
90: @application_configuration
91: end
# File lib/mcollective/application.rb, line 291
291: def disconnect
292: MCollective::PluginManager["connector_plugin"].disconnect
293: rescue
294: end
A helper that creates a consistent exit code for applications by looking at an instance of MCollective::RPC::Stats
Exit with 0 if nodes were discovered and all passed Exit with 0 if no discovery were done and > 0 responses were received Exit with 1 if no nodes were discovered Exit with 2 if nodes were discovered but some RPC requests failed Exit with 3 if nodes were discovered, but not responses receivedif Exit with 4 if no discovery were done and no responses were received
# File lib/mcollective/application.rb, line 312
312: def halt(stats)
313: request_stats = {:discoverytime => 0,
314: :discovered => 0,
315: :failcount => 0}.merge(stats.to_hash)
316:
317: # was discovery done?
318: if request_stats[:discoverytime] != 0
319: # was any nodes discovered
320: if request_stats[:discovered] == 0
321: exit 1
322:
323: # nodes were discovered, did we get responses
324: elsif request_stats[:responses] == 0
325: exit 3
326:
327: else
328: # we got responses and discovery was done, no failures
329: if request_stats[:failcount] == 0
330: exit 0
331: else
332: exit 2
333: end
334: end
335: else
336: # discovery wasnt done and we got no responses
337: if request_stats[:responses] == 0
338: exit 4
339: else
340: exit 0
341: end
342: end
343: end
# File lib/mcollective/application.rb, line 269
269: def help
270: application_parse_options(true)
271: end
The active options hash used for MC::Client and other configuration
# File lib/mcollective/application.rb, line 94
94: def options
95: @options
96: end
Wrapper around MC::RPC#rpcclient that forcably supplies our options hash if someone forgets to pass in options in an application the filters and other cli options wouldnt take effect which could have a disasterous outcome
# File lib/mcollective/application.rb, line 348
348: def rpcclient(agent, flags = {})
349: flags[:options] = options unless flags.include?(:options)
350:
351: super
352: end
The main logic loop, builds up the options, validate configuration and calls the main as supplied by the user. Disconnects when done and pass any exception onto the application_failure helper
# File lib/mcollective/application.rb, line 276
276: def run
277: application_parse_options
278:
279: validate_configuration(configuration) if respond_to?(:validate_configuration)
280:
281: Util.setup_windows_sleeper if Util.windows?
282:
283: main
284:
285: disconnect
286:
287: rescue Exception => e
288: application_failure(e)
289: end
# File lib/mcollective/application.rb, line 205
205: def validate_cli_options
206: # Check all required parameters were set
207: validation_passed = true
208: application_cli_arguments.each do |carg|
209: # Check for required arguments
210: if carg[:required]
211: unless configuration[ carg[:name] ]
212: validation_passed = false
213: STDERR.puts "The #{carg[:name]} option is mandatory"
214: end
215: end
216: end
217:
218: unless validation_passed
219: STDERR.puts "\nPlease run with --help for detailed help"
220: exit 1
221: end
222:
223:
224: end
Calls the supplied block in an option for validation, an error raised will log to STDERR and exit the application
# File lib/mcollective/application.rb, line 100
100: def validate_option(blk, name, value)
101: validation_result = blk.call(value)
102:
103: unless validation_result == true
104: STDERR.puts "Validation of #{name} failed: #{validation_result}"
105: exit 1
106: end
107: end
| Class | MCollective::DDLValidationError |
| In: |
lib/mcollective.rb
|
| Parent: | RuntimeError |
| Class | MCollective::RPCAborted |
| In: |
lib/mcollective.rb
|
| Parent: | RPCError |
| Class | MCollective::Connector::Base |
| In: |
lib/mcollective/connector/base.rb
|
| Parent: | Object |
| Class | MCollective::Applications |
| In: |
lib/mcollective/applications.rb
|
| Parent: | Object |
# File lib/mcollective/applications.rb, line 3 3: def self.[](appname) 4: load_application(appname) 5: PluginManager["#{appname}_application"] 6: end
Filters a string of opts out using Shellwords keeping only things related to —config and -c
# File lib/mcollective/applications.rb, line 60
60: def self.filter_extra_options(opts)
61: res = ""
62: words = Shellwords.shellwords(opts)
63: words.each_with_index do |word,idx|
64: if word == "-c"
65: return "--config=#{words[idx + 1]}"
66: elsif word == "--config"
67: return "--config=#{words[idx + 1]}"
68: elsif word =~ /\-c=/
69: return word
70: elsif word =~ /\-\-config=/
71: return word
72: end
73: end
74:
75: return ""
76: end
Returns an array of applications found in the lib dirs
# File lib/mcollective/applications.rb, line 36
36: def self.list
37: load_config
38:
39: applist = []
40:
41: Config.instance.libdir.each do |libdir|
42: applicationdir = "#{libdir}/mcollective/application"
43: next unless File.directory?(applicationdir)
44:
45: Dir.entries(applicationdir).grep(/\.rb$/).each do |application|
46: applist << File.basename(application, ".rb")
47: end
48: end
49:
50: applist
51: rescue SystemExit
52: exit 1
53: rescue Exception => e
54: STDERR.puts "Failed to generate application list: #{e.class}: #{e}"
55: exit 1
56: end
# File lib/mcollective/applications.rb, line 26
26: def self.load_application(appname)
27: return if PluginManager.include?("#{appname}_application")
28:
29: load_config
30:
31: PluginManager.loadclass "MCollective::Application::#{appname.capitalize}"
32: PluginManager << {:type => "#{appname}_application", :class => "MCollective::Application::#{appname.capitalize}"}
33: end
We need to know the config file in order to know the libdir so that we can find applications.
The problem is the CLI might be stuffed with options only the app in the libdir might understand so we have a chicken and egg situation.
We‘re parsing and filtering MCOLLECTIVE_EXTRA_OPTS removing all but config related options and parsing the options looking just for the config file.
We‘re handling failures gracefully and finally restoring the ARG and MCOLLECTIVE_EXTRA_OPTS to the state they were before we started parsing.
This is mostly a hack, when we‘re redoing how config works this stuff should be made less sucky
# File lib/mcollective/applications.rb, line 95
95: def self.load_config
96: return if Config.instance.configured
97:
98: original_argv = ARGV.clone
99: original_extra_opts = ENV["MCOLLECTIVE_EXTRA_OPTS"].clone rescue nil
100: configfile = nil
101:
102: parser = OptionParser.new
103: parser.on("--config CONFIG", "-c", "Config file") do |f|
104: configfile = f
105: end
106:
107: parser.program_name = $0
108:
109: parser.on("--help")
110:
111: # avoid option parsers own internal version handling that sux
112: parser.on("-v", "--verbose")
113:
114: if original_extra_opts
115: begin
116: # optparse will parse the whole ENV in one go and refuse
117: # to play along with the retry trick I do below so in
118: # order to handle unknown options properly I parse out
119: # only -c and --config deleting everything else and
120: # then restore the environment variable later when I
121: # am done with it
122: ENV["MCOLLECTIVE_EXTRA_OPTS"] = filter_extra_options(ENV["MCOLLECTIVE_EXTRA_OPTS"].clone)
123: parser.environment("MCOLLECTIVE_EXTRA_OPTS")
124: rescue Exception => e
125: Log.error("Failed to parse MCOLLECTIVE_EXTRA_OPTS: #{e}")
126: end
127:
128: ENV["MCOLLECTIVE_EXTRA_OPTS"] = original_extra_opts.clone
129: end
130:
131: begin
132: parser.parse!
133: rescue OptionParser::InvalidOption => e
134: retry
135: end
136:
137: ARGV.clear
138: original_argv.each {|a| ARGV << a}
139:
140: configfile = Util.config_file_for_user unless configfile
141:
142: Config.instance.loadconfig(configfile)
143: end
# File lib/mcollective/applications.rb, line 8
8: def self.run(appname)
9: load_config
10:
11: begin
12: load_application(appname)
13: rescue Exception => e
14: e.backtrace.first << RPC::Helpers.colorize(:red, " <----")
15: STDERR.puts "Application '#{appname}' failed to load:"
16: STDERR.puts
17: STDERR.puts RPC::Helpers.colorize(:red, " #{e} (#{e.class})")
18: STDERR.puts
19: STDERR.puts " %s" % [e.backtrace.join("\n ")]
20: exit 1
21: end
22:
23: PluginManager["#{appname}_application"].run
24: end
| Class | MCollective::UnknownRPCError |
| In: |
lib/mcollective.rb
|
| Parent: | RPCError |
| Class | MCollective::MsgDoesNotMatchRequestID |
| In: |
lib/mcollective.rb
|
| Parent: | RuntimeError |
| Class | MCollective::SSL |
| In: |
lib/mcollective/ssl.rb
|
| Parent: | Object |
A class that assists in encrypting and decrypting data using a combination of RSA and AES
Data will be AES encrypted for speed, the Key used in # the AES stage will be encrypted using RSA
ssl = SSL.new(public_key, private_key, passphrase)
data = File.read("largefile.dat")
crypted_data = ssl.encrypt_with_private(data)
pp crypted_data
This will result in a hash of data like:
crypted = {:key => "crd4NHvG....=",
:data => "XWXlqN+i...=="}
The key and data will all be base 64 encoded already by default you can pass a 2nd parameter as false to encrypt_with_private and counterparts that will prevent the base 64 encoding
You can pass the data hash into ssl.decrypt_with_public which should return your original data
There are matching methods for using a public key to encrypt data to be decrypted using a private key
| private_key_file | [R] | |
| public_key_file | [R] | |
| ssl_cipher | [R] |
# File lib/mcollective/ssl.rb, line 195
195: def self.base64_decode(string)
196: Base64.decode64(string)
197: end
# File lib/mcollective/ssl.rb, line 186
186: def self.base64_encode(string)
187: Base64.encode64(string)
188: end
# File lib/mcollective/ssl.rb, line 203
203: def self.md5(string)
204: Digest::MD5.hexdigest(string)
205: end
# File lib/mcollective/ssl.rb, line 37
37: def initialize(pubkey=nil, privkey=nil, passphrase=nil, cipher=nil)
38: @public_key_file = pubkey
39: @private_key_file = privkey
40:
41: @public_key = read_key(:public, pubkey)
42: @private_key = read_key(:private, privkey, passphrase)
43:
44: @ssl_cipher = "aes-256-cbc"
45: @ssl_cipher = Config.instance.ssl_cipher if Config.instance.ssl_cipher
46: @ssl_cipher = cipher if cipher
47:
48: raise "The supplied cipher '#{@ssl_cipher}' is not supported" unless OpenSSL::Cipher.ciphers.include?(@ssl_cipher)
49: end
decrypts a string given key, iv and data
# File lib/mcollective/ssl.rb, line 158
158: def aes_decrypt(key, crypt_string)
159: cipher = OpenSSL::Cipher::Cipher.new(ssl_cipher)
160:
161: cipher.decrypt
162: cipher.key = key
163: cipher.pkcs5_keyivgen(key)
164: decrypted_data = cipher.update(crypt_string) + cipher.final
165: end
encrypts a string, returns a hash of key, iv and data
# File lib/mcollective/ssl.rb, line 144
144: def aes_encrypt(plain_string)
145: cipher = OpenSSL::Cipher::Cipher.new(ssl_cipher)
146: cipher.encrypt
147:
148: key = cipher.random_key
149:
150: cipher.key = key
151: cipher.pkcs5_keyivgen(key)
152: encrypted_data = cipher.update(plain_string) + cipher.final
153:
154: {:key => key, :data => encrypted_data}
155: end
base 64 decode a string
# File lib/mcollective/ssl.rb, line 191
191: def base64_decode(string)
192: SSL.base64_decode(string)
193: end
base 64 encode a string
# File lib/mcollective/ssl.rb, line 182
182: def base64_encode(string)
183: SSL.base64_encode(string)
184: end
Decrypts data, expects a hash as create with crypt_with_public
# File lib/mcollective/ssl.rb, line 88
88: def decrypt_with_private(crypted, base64=true)
89: raise "Crypted data should include a key" unless crypted.include?(:key)
90: raise "Crypted data should include data" unless crypted.include?(:data)
91:
92: if base64
93: key = rsa_decrypt_with_private(base64_decode(crypted[:key]))
94: aes_decrypt(key, base64_decode(crypted[:data]))
95: else
96: key = rsa_decrypt_with_private(crypted[:key])
97: aes_decrypt(key, crypted[:data])
98: end
99: end
Decrypts data, expects a hash as create with crypt_with_private
# File lib/mcollective/ssl.rb, line 102
102: def decrypt_with_public(crypted, base64=true)
103: raise "Crypted data should include a key" unless crypted.include?(:key)
104: raise "Crypted data should include data" unless crypted.include?(:data)
105:
106: if base64
107: key = rsa_decrypt_with_public(base64_decode(crypted[:key]))
108: aes_decrypt(key, base64_decode(crypted[:data]))
109: else
110: key = rsa_decrypt_with_public(crypted[:key])
111: aes_decrypt(key, crypted[:data])
112: end
113: end
Encrypts supplied data using AES and then encrypts using RSA the key and IV
Return a hash with everything optionally base 64 encoded
# File lib/mcollective/ssl.rb, line 73
73: def encrypt_with_private(plain_text, base64=true)
74: crypted = aes_encrypt(plain_text)
75:
76: if base64
77: key = base64_encode(rsa_encrypt_with_private(crypted[:key]))
78: data = base64_encode(crypted[:data])
79: else
80: key = rsa_encrypt_with_private(crypted[:key])
81: data = crypted[:data]
82: end
83:
84: {:key => key, :data => data}
85: end
Encrypts supplied data using AES and then encrypts using RSA the key and IV
Return a hash with everything optionally base 64 encoded
# File lib/mcollective/ssl.rb, line 55
55: def encrypt_with_public(plain_text, base64=true)
56: crypted = aes_encrypt(plain_text)
57:
58: if base64
59: key = base64_encode(rsa_encrypt_with_public(crypted[:key]))
60: data = base64_encode(crypted[:data])
61: else
62: key = rsa_encrypt_with_public(crypted[:key])
63: data = crypted[:data]
64: end
65:
66: {:key => key, :data => data}
67: end
Reads either a :public or :private key from disk, uses an optional passphrase to read the private key
# File lib/mcollective/ssl.rb, line 209
209: def read_key(type, key=nil, passphrase=nil)
210: return key if key.nil?
211:
212: raise "Could not find key #{key}" unless File.exist?(key)
213:
214: if type == :public
215: begin
216: key = OpenSSL::PKey::RSA.new(File.read(key))
217: rescue OpenSSL::PKey::RSAError
218: key = OpenSSL::X509::Certificate.new(File.read(key)).public_key
219: end
220:
221: # Ruby < 1.9.3 had a bug where it does not correctly clear the
222: # queue of errors while reading a key. It tries various ways
223: # to read the key and each failing attempt pushes an error onto
224: # the queue. With pubkeys only the 3rd attempt pass leaving 2
225: # stale errors on the error queue.
226: #
227: # In 1.9.3 they fixed this by simply discarding the errors after
228: # every attempt. So we simulate this fix here for older rubies
229: # as without it we get SSL_read errors from the Stomp+TLS sessions
230: #
231: # We do this only on 1.8 relying on 1.9.3 to do the right thing
232: # and we do not support 1.9 less than 1.9.3
233: #
234: # See http://bugs.ruby-lang.org/issues/4550
235: OpenSSL.errors if Util.ruby_version =~ /^1.8/
236:
237: return key
238: elsif type == :private
239: return OpenSSL::PKey::RSA.new(File.read(key), passphrase)
240: else
241: raise "Can only load :public or :private keys"
242: end
243: end
Use the private key to RSA decrypt data
# File lib/mcollective/ssl.rb, line 123
123: def rsa_decrypt_with_private(crypt_string)
124: raise "No private key set" unless @private_key
125:
126: @private_key.private_decrypt(crypt_string)
127: end
Use the public key to RSA decrypt data
# File lib/mcollective/ssl.rb, line 137
137: def rsa_decrypt_with_public(crypt_string)
138: raise "No public key set" unless @public_key
139:
140: @public_key.public_decrypt(crypt_string)
141: end
Use the private key to RSA encrypt data
# File lib/mcollective/ssl.rb, line 130
130: def rsa_encrypt_with_private(plain_string)
131: raise "No private key set" unless @private_key
132:
133: @private_key.private_encrypt(plain_string)
134: end
Use the public key to RSA encrypt data
# File lib/mcollective/ssl.rb, line 116
116: def rsa_encrypt_with_public(plain_string)
117: raise "No public key set" unless @public_key
118:
119: @public_key.public_encrypt(plain_string)
120: end
Signs a string using the private key
# File lib/mcollective/ssl.rb, line 168
168: def sign(string, base64=false)
169: sig = @private_key.sign(OpenSSL::Digest::SHA1.new, string)
170:
171: base64 ? base64_encode(sig) : sig
172: end
Using the public key verifies that a string was signed using the private key
# File lib/mcollective/ssl.rb, line 175
175: def verify_signature(signature, string, base64=false)
176: signature = base64_decode(signature) if base64
177:
178: @public_key.verify(OpenSSL::Digest::SHA1.new, signature, string)
179: end
| Class | MCollective::Runner |
| In: |
lib/mcollective/runner.rb
|
| Parent: | Object |
The main runner for the daemon, supports running in the foreground and the background, keeps detailed stats and provides hooks to access all this information
# File lib/mcollective/runner.rb, line 6
6: def initialize(configfile)
7: @config = Config.instance
8: @config.loadconfig(configfile) unless @config.configured
9:
10: @stats = PluginManager["global_stats"]
11:
12: @security = PluginManager["security_plugin"]
13: @security.initiated_by = :node
14:
15: @connection = PluginManager["connector_plugin"]
16: @connection.connect
17:
18: @agents = Agents.new
19:
20: unless Util.windows?
21: Signal.trap("USR1") do
22: Log.info("Reloading all agents after receiving USR1 signal")
23: @agents.loadagents
24: end
25:
26: Signal.trap("USR2") do
27: Log.info("Cycling logging level due to USR2 signal")
28: Log.cycle_level
29: end
30: else
31: Util.setup_windows_sleeper
32: end
33: end
Starts the main loop, before calling this you should initialize the MCollective::Config singleton.
# File lib/mcollective/runner.rb, line 36
36: def run
37: Util.subscribe(Util.make_subscriptions("mcollective", :broadcast))
38: Util.subscribe(Util.make_subscriptions("mcollective", :directed)) if @config.direct_addressing
39:
40: # Start the registration plugin if interval isn't 0
41: begin
42: PluginManager["registration_plugin"].run(@connection) unless @config.registerinterval == 0
43: rescue Exception => e
44: Log.error("Failed to start registration plugin: #{e}")
45: end
46:
47: loop do
48: begin
49: request = receive
50:
51: if request.agent == "mcollective"
52: controlmsg(request)
53: else
54: agentmsg(request)
55: end
56: rescue SignalException => e
57: Log.warn("Exiting after signal: #{e}")
58: @connection.disconnect
59: raise
60:
61: rescue MsgTTLExpired => e
62: Log.warn(e)
63:
64: rescue NotTargettedAtUs => e
65: Log.debug("Message does not pass filters, ignoring")
66:
67: rescue Exception => e
68: Log.warn("Failed to handle message: #{e} - #{e.class}\n")
69: Log.warn(e.backtrace.join("\n\t"))
70: end
71: end
72: end
| Class | MCollective::PluginPackager::StandardDefinition |
| In: |
lib/mcollective/pluginpackager/standard_definition.rb
|
| Parent: | Object |
| dependencies | [RW] | |
| iteration | [RW] | |
| mccommon | [RW] | |
| mcserver | [RW] | |
| metadata | [RW] | |
| packagedata | [RW] | |
| path | [RW] | |
| plugintype | [RW] | |
| postinstall | [RW] | |
| preinstall | [RW] | |
| target_path | [RW] | |
| vendor | [RW] |
# File lib/mcollective/pluginpackager/standard_definition.rb, line 8
8: def initialize(path, name, vendor, preinstall, postinstall, iteration, dependencies, mcodependency, plugintype)
9: @plugintype = plugintype
10: @path = path
11: @packagedata = {}
12: @iteration = iteration || 1
13: @preinstall = preinstall
14: @postinstall = postinstall
15: @vendor = vendor || "Puppet Labs"
16: @dependencies = dependencies || []
17: @mcserver = mcodependency[:server] || "mcollective"
18: @mccommon = mcodependency[:common] || "mcollective-common"
19: @target_path = File.expand_path(@path)
20: @metadata = PluginPackager.get_metadata(@path, @plugintype)
21: @metadata[:name] = (name || @metadata[:name]).downcase.gsub(" ", "-")
22: identify_packages
23: end
Obtain list of common files
# File lib/mcollective/pluginpackager/standard_definition.rb, line 51
51: def common
52: common = {:files => [],
53: :dependencies => @dependencies.clone << @mccommon,
54: :description => "Common libraries for #{@name} connector plugin"}
55:
56: commondir = File.join(@path, "util")
57: if PluginPackager.check_dir_present commondir
58: common[:files] = Dir.glob(File.join(commondir, "*"))
59: return common
60: else
61: return nil
62: end
63: end
Identify present packages and populate the packagedata hash
# File lib/mcollective/pluginpackager/standard_definition.rb, line 26
26: def identify_packages
27: common_package = common
28: @packagedata[:common] = common_package if common_package
29: plugin_package = plugin
30: @packagedata[@plugintype] = plugin_package if plugin_package
31: end
Obtain standard plugin files and dependencies
# File lib/mcollective/pluginpackager/standard_definition.rb, line 34
34: def plugin
35: plugindata = {:files => [],
36: :dependencies => @dependencies.clone << @mcserver,
37: :description => "#{@name} #{@plugintype} plugin for the Marionette Collective."}
38:
39: plugindir = File.join(@path, @plugintype.to_s)
40: if PluginPackager.check_dir_present plugindir
41: plugindata[:files] = Dir.glob(File.join(plugindir, "*"))
42: else
43: return nil
44: end
45:
46: plugindata[:dependencies] <<"mcollective-#{@metadata[:name]}-common" if @packagedata[:common]
47: plugindata
48: end
| Class | MCollective::PluginPackager::AgentDefinition |
| In: |
lib/mcollective/pluginpackager/agent_definition.rb
|
| Parent: | Object |
MCollective Agent Plugin package
| dependencies | [RW] | |
| iteration | [RW] | |
| mcclient | [RW] | |
| mccommon | [RW] | |
| mcserver | [RW] | |
| metadata | [RW] | |
| packagedata | [RW] | |
| path | [RW] | |
| plugintype | [RW] | |
| postinstall | [RW] | |
| preinstall | [RW] | |
| target_path | [RW] | |
| vendor | [RW] |
# File lib/mcollective/pluginpackager/agent_definition.rb, line 8
8: def initialize(path, name, vendor, preinstall, postinstall, iteration, dependencies, mcodependency, plugintype)
9: @plugintype = plugintype
10: @path = path
11: @packagedata = {}
12: @iteration = iteration || 1
13: @preinstall = preinstall
14: @postinstall = postinstall
15: @vendor = vendor || "Puppet Labs"
16: @mcserver = mcodependency[:server] || "mcollective"
17: @mcclient = mcodependency[:client] || "mcollective-client"
18: @mccommon = mcodependency[:common] || "mcollective-common"
19: @dependencies = dependencies || []
20: @target_path = File.expand_path(@path)
21: @metadata = PluginPackager.get_metadata(@path, "agent")
22: @metadata[:name] = (name || @metadata[:name]).downcase.gsub(" ", "-")
23: identify_packages
24: end
Obtain Agent package files and dependencies.
# File lib/mcollective/pluginpackager/agent_definition.rb, line 37
37: def agent
38: agent = {:files => [],
39: :dependencies => @dependencies.clone << @mcserver,
40: :description => "Agent plugin for #{@metadata[:name]}"}
41:
42: agentdir = File.join(@path, "agent")
43:
44: if PluginPackager.check_dir_present agentdir
45: ddls = Dir.glob(File.join(agentdir, "*.ddl"))
46: agent[:files] = (Dir.glob(File.join(agentdir, "*")) - ddls)
47: implementations = Dir.glob(File.join(@metadata[:name], "**"))
48: agent[:files] += implementations unless implementations.empty?
49: else
50: return nil
51: end
52: agent[:dependencies] << "mcollective-#{@metadata[:name]}-common" if @packagedata[:common]
53: agent
54: end
Obtain client package files and dependencies.
# File lib/mcollective/pluginpackager/agent_definition.rb, line 57
57: def client
58: client = {:files => [],
59: :dependencies => @dependencies.clone << @mcclient,
60: :description => "Client plugin for #{@metadata[:name]}"}
61:
62: clientdir = File.join(@path, "application")
63: bindir = File.join(@path, "bin")
64: ddldir = File.join(@path, "agent")
65:
66: client[:files] += Dir.glob(File.join(clientdir, "*")) if PluginPackager.check_dir_present clientdir
67: client[:files] += Dir.glob(File.join(bindir,"*")) if PluginPackager.check_dir_present bindir
68: client[:files] += Dir.glob(File.join(ddldir, "*.ddl")) if PluginPackager.check_dir_present ddldir
69: client[:dependencies] << "mcollective-#{@metadata[:name]}-common" if @packagedata[:common]
70: client[:files].empty? ? nil : client
71: end
Obtain common package files and dependencies.
# File lib/mcollective/pluginpackager/agent_definition.rb, line 74
74: def common
75: common = {:files =>[],
76: :dependencies => @dependencies.clone << @mccommon,
77: :description => "Common libraries for #{@metadata[:name]}"}
78:
79: commondir = File.join(@path, "util")
80: common[:files] += Dir.glob(File.join(commondir,"*")) if PluginPackager.check_dir_present commondir
81: common[:files].empty? ? nil : common
82: end
Identify present packages and populate packagedata hash.
# File lib/mcollective/pluginpackager/agent_definition.rb, line 27
27: def identify_packages
28: common_package = common
29: @packagedata[:common] = common_package if common_package
30: agent_package = agent
31: @packagedata[:agent] = agent_package if agent_package
32: client_package = client
33: @packagedata[:client] = client_package if client_package
34: end
| Class | MCollective::MissingRPCData |
| In: |
lib/mcollective.rb
|
| Parent: | RPCError |
| Class | MCollective::UnknownRPCAction |
| In: |
lib/mcollective.rb
|
| Parent: | RPCError |
| Class | MCollective::Logger::File_logger |
| In: |
lib/mcollective/logger/file_logger.rb
|
| Parent: | Base |
Impliments a file based logger using the standard ruby logger class
To configure you should set:
- config.logfile - config.keeplogs defaults to 2097152 - config.max_log_size defaults to 5
# File lib/mcollective/logger/file_logger.rb, line 37
37: def log(level, from, msg)
38: @logger.add(map_level(level)) { "#{from} #{msg}" }
39: rescue
40: # if this fails we probably cant show the user output at all,
41: # STDERR it as last resort
42: STDERR.puts("#{level}: #{msg}")
43: end
# File lib/mcollective/logger/file_logger.rb, line 22
22: def set_logging_level(level)
23: @logger.level = map_level(level)
24: rescue Exception => e
25: @logger.level = ::Logger::DEBUG
26: log(:error, "", "Could not set logging to #{level} using debug instead: #{e.class} #{e}")
27: end
# File lib/mcollective/logger/file_logger.rb, line 13
13: def start
14: config = Config.instance
15:
16: @logger = ::Logger.new(config.logfile, config.keeplogs, config.max_log_size)
17: @logger.formatter = ::Logger::Formatter.new
18:
19: set_level(config.loglevel.to_sym)
20: end
| Class | MCollective::Logger::Base |
| In: |
lib/mcollective/logger/base.rb
|
| Parent: | Object |
A base class for logging providers.
Logging providers should provide the following:
* start - all you need to do to setup your logging * set_logging_level - set your logging to :info, :warn, etc * valid_levels - a hash of maps from :info to your internal level name * log - what needs to be done to log a specific message
| active_level | [R] |
# File lib/mcollective/logger/base.rb, line 14
14: def initialize
15: @known_levels = [:debug, :info, :warn, :error, :fatal]
16:
17: # Sanity check the class that impliments the logging
18: @known_levels.each do |lvl|
19: raise "Logger class did not specify a map for #{lvl}" unless valid_levels.include?(lvl)
20: end
21: end
Figures out the next level and sets it
# File lib/mcollective/logger/base.rb, line 24
24: def cycle_level
25: lvl = get_next_level
26: set_level(lvl)
27:
28: log(lvl, "", "Logging level is now #{lvl.to_s.upcase}")
29: end
| Class | MCollective::Logger::Console_logger |
| In: |
lib/mcollective/logger/console_logger.rb
|
| Parent: | Base |
Impliments a syslog based logger using the standard ruby syslog class
Set some colors for various logging levels, will honor the color configuration option and return nothing if its configured not to
# File lib/mcollective/logger/console_logger.rb, line 39
39: def color(level)
40: colorize = Config.instance.color
41:
42: colors = {:error => "[31m",
43: :fatal => "[31m",
44: :warn => "[33m",
45: :info => "[32m",
46: :reset => "[0m"}
47:
48: if colorize
49: return colors[level] || ""
50: else
51: return ""
52: end
53: end
# File lib/mcollective/logger/console_logger.rb, line 24
24: def log(level, from, msg)
25: if @known_levels.index(level) >= @known_levels.index(@active_level)
26: time = Time.new.strftime("%Y/%m/%d %H:%M:%S")
27: lvltxt = colorize(level, level)
28: STDERR.puts("#{lvltxt} #{time}: #{from} #{msg}")
29: end
30: rescue
31: # if this fails we probably cant show the user output at all,
32: # STDERR it as last resort
33: STDERR.puts("#{level}: #{msg}")
34: end
# File lib/mcollective/logger/console_logger.rb, line 12
12: def set_logging_level(level)
13: # nothing to do here, we ignore high levels when we log
14: end
# File lib/mcollective/logger/console_logger.rb, line 5
5: def start
6: set_level(:info)
7:
8: config = Config.instance
9: set_level(config.loglevel.to_sym) if config.configured
10: end
| Class | MCollective::Logger::Syslog_logger |
| In: |
lib/mcollective/logger/syslog_logger.rb
|
| Parent: | Base |
Implements a syslog based logger using the standard ruby syslog class
# File lib/mcollective/logger/syslog_logger.rb, line 42
42: def log(level, from, msg)
43: if @known_levels.index(level) >= @known_levels.index(@active_level)
44: Syslog.send(map_level(level), "#{from} #{msg}")
45: end
46: rescue
47: # if this fails we probably cant show the user output at all,
48: # STDERR it as last resort
49: STDERR.puts("#{level}: #{msg}")
50: end
# File lib/mcollective/logger/syslog_logger.rb, line 30
30: def set_logging_level(level)
31: # noop
32: end
# File lib/mcollective/logger/syslog_logger.rb, line 9
9: def start
10: config = Config.instance
11:
12: facility = syslog_facility(config.logfacility)
13: level = config.loglevel.to_sym
14:
15: Syslog.close if Syslog.opened?
16: Syslog.open(File.basename($0), 3, facility)
17:
18: set_level(level)
19: end
# File lib/mcollective/logger/syslog_logger.rb, line 21
21: def syslog_facility(facility)
22: begin
23: Syslog.const_get("LOG_#{facility.upcase}")
24: rescue NameError => e
25: STDERR.puts "Invalid syslog facility #{facility} supplied, reverting to USER"
26: Syslog::LOG_USER
27: end
28: end
| Class | Dir |
| In: |
lib/mcollective/monkey_patches.rb
|
| Parent: | Object |
# File lib/mcollective/monkey_patches.rb, line 55
55: def self.mktmpdir(prefix_suffix=nil, tmpdir=nil)
56: case prefix_suffix
57: when nil
58: prefix = "d"
59: suffix = ""
60: when String
61: prefix = prefix_suffix
62: suffix = ""
63: when Array
64: prefix = prefix_suffix[0]
65: suffix = prefix_suffix[1]
66: else
67: raise ArgumentError, "unexpected prefix_suffix: #{prefix_suffix.inspect}"
68: end
69: tmpdir ||= Dir.tmpdir
70: t = Time.now.strftime("%Y%m%d")
71: n = nil
72: begin
73: path = "#{tmpdir}/#{prefix}#{t}-#{$$}-#{rand(0x100000000).to_s(36)}"
74: path << "-#{n}" if n
75: path << suffix
76: Dir.mkdir(path, 0700)
77: rescue Errno::EEXIST
78: n ||= 0
79: n += 1
80: retry
81: end
82:
83: if block_given?
84: begin
85: yield path
86: ensure
87: FileUtils.remove_entry_secure path
88: end
89: else
90: path
91: end
92: end
# File lib/mcollective/monkey_patches.rb, line 94
94: def self.tmpdir
95: tmp = '.'
96: for dir in [ENV['TMPDIR'], ENV['TMP'], ENV['TEMP'], '/tmp']
97: if dir and stat = File.stat(dir) and stat.directory? and stat.writable?
98: tmp = dir
99: break
100: end rescue nil
101: end
102: File.expand_path(tmp)
103: end
Framework to build and run Systems Administration agents running on a publish/subscribe middleware system. The system allows you to treat your network as the only true source of the state of your platform via discovery agents and allow you to run agents matching discovery criteria.
For an overview of the idea behind this and what it enables please see:
http://www.devco.net/archives/2009/10/18/middleware_for_systems_administration.php
| VERSION | = | "@DEVELOPMENT_VERSION@" |
action "echo" do validate :message, String implemented_by "/tmp/echo.py" endThe following Python script will implement the echo action externally replying with _message_ and _timestamp_
#!/bin/env python
import mcollectiveah
import time
mc = mcollectiveah.MCollectiveAction()
mc.reply['message'] = mc.request['message']
mc.reply['timestamp'] = time.strftime("%c")
mc.reply['info'] = "some text to info log in the server"
Calling it with _mco rpc_ results in:
$ mco rpc test echo message="hello world"
Determining the amount of hosts matching filter for 2 seconds .... 1
* [ ============================================================> ] 1 / 1
nephilim.ml.org : OK
{:message=>"hello world", :time=>"Tue Mar 15 19:20:53 +0000 2011"}
mcollective-2.0.0/ext/action_helpers/python/kwilczynski/ 0000755 0001750 0001750 00000000000 11747546503 022542 5 ustar jonas jonas mcollective-2.0.0/ext/action_helpers/python/kwilczynski/echo.py 0000644 0001750 0001750 00000000504 11747546503 024031 0 ustar jonas jonas #!/usr/bin/env python
import sys
import time
import mcollective_action as mc
if __name__ == '__main__':
mc = mc.MCollectiveAction()
request = mc.request()
mc.message = request['data']['message']
mc.time = time.strftime('%c')
mc.info("An example echo agent")
sys.exit(0)
# vim: set ts=4 sw=4 et :
mcollective-2.0.0/ext/action_helpers/python/kwilczynski/README.markdown 0000644 0001750 0001750 00000002035 11747546503 025243 0 ustar jonas jonas A simple helper to assist with writing MCollective actions in Python.
Given an action as below:
action "echo" do validate :message, String implemented_by "/tmp/echo.py" endThe following Python script will implement the echo action externally replying with _message_ and current _time_.
#!/usr/bin/env python
import sys
import time
import mcollective_action as mc
if __name__ == '__main__':
mc = mc.MCollectiveAction()
request = mc.request()
mc.message = request['data']['message']
mc.time = time.strftime('%c')
mc.info("Some text to info log in the server")
sys.exit(0)
Calling it with _mco rpc_ results in:
$ mco rpc test echo message="Hello World"
Determining the amount of hosts matching filter for 2 seconds .... 1
* [ ============================================================> ] 1 / 1
host.example.com : OK
{:message=>"Hello World", :time=>"Tue Mar 15 19:20:53 +0000 2011"}
This implementation was successfully tested with Python 2.4 and 2.6.
mcollective-2.0.0/ext/action_helpers/python/kwilczynski/mcollective_action.py 0000644 0001750 0001750 00000006230 11747546503 026760 0 ustar jonas jonas #!/usr/bin/env python
import os
import sys
class Error(Exception):
pass
class MissingModule(Error):
pass
class MissingFiles(Error):
pass
class MissingEnvironemntVariable(Error):
pass
class FileReadError(Error):
pass
class JSONParsingError(Error):
pass
try:
import simplejson as json
except ImportError:
raise MissingModule('Unable to load JSON module. Missing module?')
class MCollectiveAction(object):
_environment_variables = [ 'MCOLLECTIVE_REQUEST_FILE',
'MCOLLECTIVE_REPLY_FILE' ]
def __init__(self):
self._info = sys.__stdout__
self._error = sys.__stderr__
for entry in '_reply', '_request':
self.__dict__[entry] = {}
self._arguments = sys.argv[1:]
if len(self._arguments) < 2:
try:
for variable in self._environment_variables:
self._arguments.append(os.environ[variable])
except KeyError:
raise MissingEnvironemntVariable("Environment variable `%s' "
"is not set." % variable)
self._request_file, self._reply_file = self._arguments
if len(self._request_file) == 0 or len(self._reply_file) == 0:
raise MissingFiles("Both request and reply files have to be set.")
def __setattr__(self, name, value):
if name.startswith('_'):
object.__setattr__(self, name, value)
else:
self.__dict__['_reply'][name] = value
def __getattr__(self, name):
if name.startswith('_'):
return self.__dict__.get(name, None)
else:
return self.__dict__['_reply'].get(name, None)
def __del__(self):
if self._reply:
try:
file = open(self._reply_file, 'w')
json.dump(self._reply, file)
file.close()
except IOError, error:
raise FileReadError("Unable to open reply file `%s': %s" %
(self._reply_file, error))
def info(self, message):
print >> self._info, message
self._info.flush()
def error(self, message):
print >> self._error, message
self._error.flush()
def fail(self, message, exit_code=1):
self.error(message)
sys.exit(exit_code)
def reply(self):
return self._reply
def request(self):
if self._request:
return self._request
else:
try:
file = open(self._request_file, 'r')
self._request = json.load(file)
file.close()
except IOError, error:
raise FileReadError("Unable to open request file `%s': %s" %
(self._request_file, error))
except json.JSONDecodeError, error:
raise JSONParsingError("An error occurred during parsing of "
"the JSON data in the file `%s': %s" %
(self._request_file, error))
file.close()
return self._request
# vim: set ts=4 sw=4 et :
mcollective-2.0.0/ext/action_helpers/php/ 0000755 0001750 0001750 00000000000 11747546503 017427 5 ustar jonas jonas mcollective-2.0.0/ext/action_helpers/php/mcollective_action.php 0000644 0001750 0001750 00000003264 11747546503 024010 0 ustar jonas jonas infile = $_ENV["MCOLLECTIVE_REQUEST_FILE"];
$this->outfile = $_ENV["MCOLLECTIVE_REPLY_FILE"];
$this->readJSON();
}
function __destruct() {
$this->save();
}
function readJSON() {
$this->request = json_decode(file_get_contents($this->infile), true);
unset($this->request["data"]["process_results"]);
}
function save() {
file_put_contents($this->outfile, json_encode($this->request["data"]));
}
// prints a line to STDERR that will log at error level in the
// mcollectived log file
function error($msg) {
fwrite(STDERR, "$msg\n");
}
// prints a line to STDOUT that will log at info level in the
// mcollectived log file
function info($msg) {
fwrite(STDOUT, "$msg\n");
}
// logs an error message and exits with RPCAborted
function fail($msg) {
$this->error($msg);
exit(1);
}
function __get($property) {
if (isSet($this->request[$property])) {
return $this->request[$property];
} else {
throw new Exception("No $property in request");
}
}
function __set($property, $value) {
$this->request["data"][$property] = $value;
}
}
?>
mcollective-2.0.0/ext/action_helpers/php/README.markdown 0000644 0001750 0001750 00000001574 11747546503 022137 0 ustar jonas jonas A simple helper to assist with writing MCollective actions in PHP.
Given an action as below:
action "echo" do validate :message, String implemented_by "/tmp/echo.php" endThe following PHP script will implement the echo action externally replying with _message_ and _timestamp_
<?php
require("mcollective_action.php");
$mc = new MCollectiveAction();
$mc->message = $mc->data["message"];
$mc->timestamp = strftime("%c");
$mc->info("some text to info log on the server");
?>
Calling it with _mco rpc_ results in:
$ mco rpc test echo message="hello world"
Determining the amount of hosts matching filter for 2 seconds .... 1
* [ ============================================================> ] 1 / 1
nephilim.ml.org : OK
{:message=>"hello world", :time=>"Tue Mar 15 19:20:53 +0000 2011"}
mcollective-2.0.0/ext/action_helpers/perl/ 0000755 0001750 0001750 00000000000 11747546503 017602 5 ustar jonas jonas mcollective-2.0.0/ext/action_helpers/perl/Makefile.PL 0000644 0001750 0001750 00000000220 11747546503 021546 0 ustar jonas jonas #!perl
use strict;
use ExtUtils::MakeMaker;
WriteMakefile(
NAME => "MCollective::Action",
PREREQ_PM => {
"JSON" => 0,
},
);
mcollective-2.0.0/ext/action_helpers/perl/lib/ 0000755 0001750 0001750 00000000000 11747546503 020350 5 ustar jonas jonas mcollective-2.0.0/ext/action_helpers/perl/lib/MCollective/ 0000755 0001750 0001750 00000000000 11747546503 022556 5 ustar jonas jonas mcollective-2.0.0/ext/action_helpers/perl/lib/MCollective/Action.pm 0000644 0001750 0001750 00000005012 11747546503 024327 0 ustar jonas jonas package MCollective::Action;
use strict;
use warnings;
use JSON;
=head1 NAME
MCollective::Action - helper class for writing mcollective actions in perl
=head1 SYNOPSIS
In your mcollective agent
action "echo" do
validate :message, String
implemented by "/tmp/echo.perl"
end
And C
#!/usr/bin/env perl
use strict;
use MCollective::Action;
my $mc = MCollective::Action->new;
$mc->reply->{message} = $mc->request->{message};
$mc->reply->{timestamp} = time;
$mc->info("some text to log on the server");
=head1 DESCRIPTION
mcollective version 1.X introduced a mechanism for writing agent actions as
external commands. This module provides a convenient api for writing them in
perl which performs some of the boilerplate for you.
=head2 METHODS
=over
=item new
create a new MCollection::Action helper object
=cut
sub new {
my $class = shift;
my $self = bless {
request => {},
reply => {},
}, $class;
$self->_load;
return $self;
}
=item request
returns a hash reference containing the request
=cut
sub request { $_[0]->{request} }
=item reply
returns a hash reference you should populate with your reply
=cut
sub reply { $_[0]->{reply} }
sub _load {
my $self = shift;
my $file = $ENV{MCOLLECTIVE_REQUEST_FILE};
open my $fh, "<$file"
or die "Can't open '$file': $!";
my $json = do { local $/; <$fh> };
$self->{request} = JSON->new->decode( $json );
delete $self->request->{data}{process_results};
}
sub DESTROY {
my $self = shift;
$self->_save;
}
sub _save {
my $self = shift;
my $file = $ENV{MCOLLECTIVE_REPLY_FILE};
open my $fh, ">$file"
or die "Can't open '$file': $!";
print $fh JSON->new->encode( $self->reply );
}
=item info($message)
report a message into the server log
=cut
sub info {
my ($self, $message) = @_;
print STDOUT $message, "\n";
}
=item error($message)
report an error into the server log
=cut
sub error {
my ($self, $message) = @_;
print STDERR $message, "\n";
}
=item fail
reports an error and exits immediately
=cut
sub fail {
my ($self, $message) = @_;
$self->error( $message );
exit 1;
}
1;
__END__
=back
=head1 AUTHOR
Richard Clamp