mcollective-client 1.3.3

data/lib/mcollective/monkey_patches.rb

@@ -0,0 +1,104 @@
+# Make arrays of Symbols sortable
+class Symbol
+  include Comparable
+
+  def <=>(other)
+    self.to_s <=> other.to_s
+  end unless method_defined?("<=>")
+end
+
+# This provides an alias for RbConfig to Config for versions of Ruby older then
+# # version 1.8.5. This allows us to use RbConfig in place of the older Config in
+# # our code and still be compatible with at least Ruby 1.8.1.
+# require 'rbconfig'
+unless defined? ::RbConfig
+  ::RbConfig = ::Config
+end
+
+# a method # that walks an array in groups, pass a block to
+# call the block on each sub array
+class Array
+  def in_groups_of(chunk_size, padded_with=nil, &block)
+    arr = self.clone
+
+    # how many to add
+    padding = chunk_size - (arr.size % chunk_size)
+
+    # pad at the end
+    arr.concat([padded_with] * padding) unless padding == chunk_size
+
+    # how many chunks we'll make
+    count = arr.size / chunk_size
+
+    # make that many arrays
+    result = []
+    count.times {|s| result <<  arr[s * chunk_size, chunk_size]}
+
+    if block_given?
+      result.each_with_index do |a, i|
+        case block.arity
+          when 1
+            yield(a)
+          when 2
+            yield(a, (i == result.size - 1))
+          else
+            raise "Expected 1 or 2 arguments, got #{block.arity}"
+        end
+      end
+    else
+      result
+    end
+  end unless method_defined?(:in_groups_of)
+end
+
+class Dir
+  def self.mktmpdir(prefix_suffix=nil, tmpdir=nil)
+    case prefix_suffix
+    when nil
+      prefix = "d"
+      suffix = ""
+    when String
+      prefix = prefix_suffix
+      suffix = ""
+    when Array
+      prefix = prefix_suffix[0]
+      suffix = prefix_suffix[1]
+    else
+      raise ArgumentError, "unexpected prefix_suffix: #{prefix_suffix.inspect}"
+    end
+    tmpdir ||= Dir.tmpdir
+    t = Time.now.strftime("%Y%m%d")
+    n = nil
+    begin
+      path = "#{tmpdir}/#{prefix}#{t}-#{$$}-#{rand(0x100000000).to_s(36)}"
+      path << "-#{n}" if n
+      path << suffix
+      Dir.mkdir(path, 0700)
+    rescue Errno::EEXIST
+      n ||= 0
+      n += 1
+      retry
+    end
+
+    if block_given?
+      begin
+        yield path
+      ensure
+        FileUtils.remove_entry_secure path
+      end
+    else
+      path
+    end
+  end unless method_defined?(:mktmpdir)
+
+  def self.tmpdir
+    tmp = '.'
+    for dir in [ENV['TMPDIR'], ENV['TMP'], ENV['TEMP'], '/tmp']
+      if dir and stat = File.stat(dir) and stat.directory? and stat.writable?
+        tmp = dir
+        break
+      end rescue nil
+    end
+    File.expand_path(tmp)
+  end unless method_defined?(:tmpdir)
+end

data/lib/mcollective/optionparser.rb

@@ -0,0 +1,164 @@
+module MCollective
+  # A simple helper to build cli tools that supports a uniform command line
+  # layout.
+  class Optionparser
+    attr_reader :parser
+
+    # 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")
+    def initialize(defaults = {}, include_sections = nil, exclude_sections = nil)
+      @parser = ::OptionParser.new
+
+      @include = [include_sections].flatten
+      @exclude = [exclude_sections].flatten
+
+      @options = Util.default_options
+
+      @options.merge!(defaults)
+    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
+    def parse(&block)
+      yield(@parser, @options) if block_given?
+
+      add_required_options
+
+      add_common_options unless @exclude.include?("common")
+
+      @include.each do |i|
+        next if @exclude.include?(i)
+
+        options_name = "add_#{i}_options"
+        send(options_name)  if respond_to?(options_name)
+      end
+
+      @parser.environment("MCOLLECTIVE_EXTRA_OPTS")
+
+      @parser.parse!
+
+      @options[:collective] = Config.instance.main_collective unless @options[:collective]
+
+      @options
+    end
+
+    # These options will be added if you pass 'filter' into the include list of the
+    # constructor.
+    def add_filter_options
+      @parser.separator ""
+      @parser.separator "Host Filters"
+
+      @parser.on('-W', '--with FILTER', 'Combined classes and facts filter') do |f|
+        f.split(" ").each do |filter|
+          begin
+            fact_parsed = parse_fact(filter)
+            @options[:filter]["fact"] << fact_parsed
+          rescue
+            @options[:filter]["cf_class"] << filter
+          end
+        end
+      end
+
+      @parser.on('-S', '--select FILTER', 'Compound filter combining facts and classes') do |f|
+        @options[:filter]["compound"] << MCollective::Matcher::Parser.new(f).execution_stack
+      end
+
+      @parser.on('-F', '--wf', '--with-fact fact=val', 'Match hosts with a certain fact') do |f|
+        fact_parsed = parse_fact(f)
+
+        @options[:filter]["fact"] << fact_parsed if fact_parsed
+      end
+
+      @parser.on('-C', '--wc', '--with-class CLASS', 'Match hosts with a certain config management class') do |f|
+        @options[:filter]["cf_class"] << f
+      end
+
+      @parser.on('-A', '--wa', '--with-agent AGENT', 'Match hosts with a certain agent') do |a|
+        @options[:filter]["agent"] << a
+      end
+
+      @parser.on('-I', '--wi', '--with-identity IDENT', 'Match hosts with a certain configured identity') do |a|
+        @options[:filter]["identity"] << a
+      end
+    end
+
+    # These options should always be present
+    def add_required_options
+      @parser.on('-c', '--config FILE', 'Load configuratuion from file rather than default') do |f|
+        @options[:config] = f
+      end
+
+      @parser.on('-v', '--verbose', 'Be verbose') do |v|
+        @options[:verbose] = v
+      end
+
+      @parser.on('-h', '--help', 'Display this screen') do
+        puts @parser
+        exit! 1
+      end
+    end
+
+    # These options will be added to most cli tools
+    def add_common_options
+      @parser.separator ""
+      @parser.separator "Common Options"
+
+      @parser.on('-T', '--target COLLECTIVE', 'Target messages to a specific sub collective') do |f|
+        @options[:collective] = f
+      end
+
+      @parser.on('--dt', '--discovery-timeout SECONDS', Integer, 'Timeout for doing discovery') do |t|
+        @options[:disctimeout] = t
+      end
+
+      @parser.on('-t', '--timeout SECONDS', Integer, 'Timeout for calling remote agents') do |t|
+        @options[:timeout] = t
+      end
+
+      @parser.on('-q', '--quiet', 'Do not be verbose') do |v|
+        @options[:verbose] = false
+      end
+
+      @parser.on('--ttl TTL', 'Set the message validity period') do |v|
+        @options[:ttl] = v.to_i
+      end
+
+      @parser.on('--reply-to TARGET', 'Set a custom target for replies') do |v|
+        @options[:reply_to] = v
+      end
+    end
+
+    private
+    # Parse a fact filter string like foo=bar into the tuple hash thats needed
+    def parse_fact(fact)
+      Util.parse_fact_string(fact)
+    end
+
+  end
+end

data/lib/mcollective/pluginmanager.rb

@@ -0,0 +1,180 @@
+module MCollective
+  # 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.
+  module PluginManager
+    @plugins = {}
+
+    # 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.
+    def self.<<(plugin)
+      plugin[:single_instance] = true unless plugin.include?(:single_instance)
+
+      type = plugin[:type]
+      klass = plugin[:class]
+      single = plugin[:single_instance]
+
+      raise("Plugin #{type} already loaded") if @plugins.include?(type)
+
+
+      # If we get a string then store 'nil' as the instance, signalling that we'll
+      # create the class later on demand.
+      if klass.is_a?(String)
+        @plugins[type] = {:loadtime => Time.now, :class => klass, :instance => nil, :single => single}
+        Log.debug("Registering plugin #{type} with class #{klass} single_instance: #{single}")
+      else
+        @plugins[type] = {:loadtime => Time.now, :class => klass.class, :instance => klass, :single => true}
+        Log.debug("Registering plugin #{type} with class #{klass.class} single_instance: true")
+      end
+    end
+
+    # Removes a plugim the list
+    def self.delete(plugin)
+      @plugins.delete(plugin) if @plugins.include?(plugin)
+    end
+
+    # Finds out if we have a plugin with the given name
+    def self.include?(plugin)
+      @plugins.include?(plugin)
+    end
+
+    # Provides a list of plugins we know about
+    def self.pluginlist
+      @plugins.keys
+    end
+
+    # deletes all registered plugins
+    def self.clear
+      @plugins.clear
+    end
+
+    # Gets a plugin by type
+    def self.[](plugin)
+      raise("No plugin #{plugin} defined") unless @plugins.include?(plugin)
+
+      klass = @plugins[plugin][:class]
+
+      if @plugins[plugin][:single]
+        # Create an instance of the class if one hasn't been done before
+        if @plugins[plugin][:instance] == nil
+          Log.debug("Returning new plugin #{plugin} with class #{klass}")
+          @plugins[plugin][:instance] = create_instance(klass)
+        else
+          Log.debug("Returning cached plugin #{plugin} with class #{klass}")
+        end
+
+        @plugins[plugin][:instance]
+      else
+        Log.debug("Returning new plugin #{plugin} with class #{klass}")
+        create_instance(klass)
+      end
+    end
+
+    # use eval to create an instance of a class
+    def self.create_instance(klass)
+      begin
+        eval("#{klass}.new")
+      rescue Exception => e
+        raise("Could not create instance of plugin #{klass}: #{e}")
+      end
+    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
+    def self.find(type, extension="rb")
+      extension = ".#{extension}" unless extension.match(/^\./)
+
+      plugins = []
+
+      Config.instance.libdir.each do |libdir|
+        plugdir = File.join([libdir, "mcollective", type])
+        next unless File.directory?(plugdir)
+
+        Dir.new(plugdir).grep(/#{extension}$/).map do |plugin|
+          plugins << File.basename(plugin, extension)
+        end
+      end
+
+      plugins.sort.uniq
+    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/
+    def self.find_and_load(type, extension="rb")
+      extension = ".#{extension}" unless extension.match(/^\./)
+
+      klasses = find(type, extension).map do |plugin|
+        if block_given?
+          next unless yield(plugin)
+        end
+
+        "%s::%s::%s" % [ "MCollective", type.capitalize, plugin.capitalize ]
+      end.compact
+
+      klasses.sort.uniq.each {|klass| loadclass(klass, true)}
+    end
+
+    # Loads a class from file by doing some simple search/replace
+    # on class names and then doing a require.
+    def self.loadclass(klass, squash_failures=false)
+      fname = klass.gsub("::", "/").downcase + ".rb"
+
+      Log.debug("Loading #{klass} from #{fname}")
+
+      load fname
+    rescue Exception => e
+      Log.error("Failed to load #{klass}: #{e}")
+      raise unless squash_failures
+    end
+
+    # Grep's over the plugin list and returns the list found
+    def self.grep(regex)
+      @plugins.keys.grep regex
+    end
+  end
+end