mcollective-client 1.3.3

data/lib/mcollective/pluginpackager.rb

@@ -0,0 +1,26 @@
+module MCollective
+  module PluginPackager
+    # Plugin definition classes
+    autoload :AgentDefinition, "mcollective/pluginpackager/agent_definition"
+    autoload :StandardDefinition, "mcollective/pluginpackager/standard_definition"
+
+    # Package implementation plugins
+    def self.load_packagers
+      PluginManager.find_and_load("pluginpackager")
+    end
+
+    def self.[](klass)
+      const_get("#{klass}")
+    end
+
+    def self.get_metadata(path, type)
+      ddl = MCollective::RPC::DDL.new("package", false)
+      ddl.instance_eval File.read(Dir.glob(File.join(path, type, "*.ddl")).first)
+      ddl.meta
+    end
+
+    def self.check_dir_present(path)
+      (File.directory?(path) && !Dir.glob(File.join(path, "*")).empty?)
+    end
+  end
+end

data/lib/mcollective/pluginpackager/agent_definition.rb

@@ -0,0 +1,79 @@
+module MCollective
+  module PluginPackager
+    # MCollective Agent Plugin package
+    class AgentDefinition
+      attr_accessor :path, :packagedata, :metadata, :target_path, :vendor, :iteration, :postinstall
+      attr_accessor :plugintype
+
+      def initialize(path, name, vendor, postinstall, iteration, plugintype)
+        @plugintype = plugintype
+        @path = path
+        @packagedata = {}
+        @iteration = iteration || 1
+        @postinstall = postinstall
+        @vendor = vendor || "Puppet Labs"
+        @target_path = File.expand_path(@path)
+        @metadata = PluginPackager.get_metadata(@path, "agent")
+        @metadata[:name] = (name || @metadata[:name]).downcase.gsub(" ", "_")
+        identify_packages
+      end
+
+      # Identify present packages and populate packagedata hash.
+      def identify_packages
+        @packagedata[:common] = common
+        @packagedata[:agent] = agent
+        @packagedata[:client] = client
+      end
+
+      # Obtain Agent package files and dependencies.
+      def agent
+        agent = {:files => [],
+                 :dependencies => ["mcollective"],
+                 :description => "Agent plugin for #{@metadata[:name]}"}
+
+        agentdir = File.join(@path, "agent")
+
+        if PluginPackager.check_dir_present agentdir
+          ddls = Dir.glob(File.join(agentdir, "*.ddl"))
+          agent[:files] = (Dir.glob(File.join(agentdir, "*")) - ddls)
+          implementations = Dir.glob(File.join(@metadata[:name], "**"))
+          agent[:files] += implementations unless implementations.empty?
+        else
+          return nil
+        end
+
+        agent[:dependencies] << "mcollective-#{@metadata[:name]}-common" if @packagedata[:common]
+        agent
+      end
+
+      # Obtain client package files and dependencies.
+      def client
+        client = {:files => [],
+                  :dependencies => ["mcollective-client"],
+                  :description => "Client plugin for #{@metadata[:name]}"}
+
+        clientdir = File.join(@path, "application")
+        bindir = File.join(@path, "bin")
+        ddldir = File.join(@path, "agent")
+
+        client[:files] += Dir.glob(File.join(clientdir, "*")) if PluginPackager.check_dir_present clientdir
+        client[:files] += Dir.glob(File.join(bindir,"*")) if PluginPackager.check_dir_present bindir
+        client[:files] += Dir.glob(File.join(ddldir, "*.ddl")) if PluginPackager.check_dir_present ddldir
+        client[:dependencies] << "mcollective-#{@metadata[:name]}-common" if @packagedata[:common]
+        client[:files].empty? ? nil : client
+      end
+
+      # Obtain common package files and dependencies.
+      def common
+        common = {:files =>[],
+                  :dependencies => ["mcollective-common"],
+                  :description => "Common libraries for #{@metadata[:name]}"}
+
+        commondir = File.join(@path, "util")
+        common[:files] += Dir.glob(File.join(commondir,"*")) if PluginPackager.check_dir_present commondir
+        common[:files].empty? ? nil : common
+      end
+
+    end
+  end
+end

data/lib/mcollective/pluginpackager/standard_definition.rb

@@ -0,0 +1,59 @@
+module MCollective
+  module PluginPackager
+    class StandardDefinition
+      attr_accessor :path, :packagedata, :metadata, :target_path, :vendor, :iteration, :postinstall
+      attr_accessor :plugintype
+
+      def initialize(path, name, vendor, postinstall, iteration, plugintype)
+        @plugintype = plugintype
+        @path = path
+        @packagedata = {}
+        @iteration = iteration || 1
+        @postinstall = postinstall
+        @vendor = vendor || "Puppet Labs"
+        @target_path = File.expand_path(@path)
+        @metadata = PluginPackager.get_metadata(@path, @plugintype)
+        @metadata[:name] = (name || @metadata[:name]).downcase.gsub(" ", "_")
+        identify_packages
+      end
+
+      # Identify present packages and populate the packagedata hash
+      def identify_packages
+        @packagedata[:common] = common
+        @packagedata[@plugintype] = plugin
+      end
+
+      # Obtain standard plugin files and dependencies
+      def plugin
+        plugindata = {:files => [],
+                      :dependencies => ["mcollective"],
+                      :description => "#{@name} #{@plugintype} plugin for the Marionette Collective."}
+
+        plugindir = File.join(@path, @plugintype.to_s)
+        if PluginPackager.check_dir_present plugindir
+          plugindata[:files] = Dir.glob(File.join(plugindir, "*"))
+        else
+          return nil
+        end
+
+        plugindata[:dependencies] <<"mcollective-#{@metadata[:name]}-common" if @packagedata[:common]
+        plugindata
+      end
+
+      # Obtain list of common files
+      def common
+        common = {:files => [],
+                  :dependencies => ["mcolelctive-common"],
+                  :description => "Common libraries for #{@name} connector plugin"}
+
+        commondir = File.join(@path, "util")
+        if PluginPackager.check_dir_present commondir
+          common[:files] = Dir.glob(File.join(commondir, "*"))
+          return common
+        else
+          return nil
+        end
+      end
+    end
+  end
+end

data/lib/mcollective/registration.rb

@@ -0,0 +1,16 @@
+module MCollective
+  # 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_
+  module Registration
+    autoload :Base, "mcollective/registration/base"
+  end
+end

data/lib/mcollective/registration/base.rb

@@ -0,0 +1,75 @@
+module MCollective
+  module Registration
+    # 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.
+    class Base
+      # Register plugins that inherits base
+      def self.inherited(klass)
+        PluginManager << {:type => "registration_plugin", :class => klass.to_s}
+      end
+
+      # Creates a background thread that periodically send a registration notice.
+      #
+      # The actual registration notices comes from the 'body' method of the registration
+      # plugins.
+      def run(connection)
+        return false if interval == 0
+
+        Thread.new do
+          loop do
+            begin
+              publish(body)
+
+              sleep interval
+            rescue Exception => e
+              Log.error("Sending registration message failed: #{e}")
+              sleep interval
+            end
+          end
+        end
+      end
+
+      def config
+        Config.instance
+      end
+
+      def msg_filter
+        {"agent" => "registration"}
+      end
+
+      def target_collective
+        main_collective = config.main_collective
+
+        collective = config.registration_collective || main_collective
+
+        unless config.collectives.include?(collective)
+          Log.warn("Sending registration to #{main_collective}: #{collective} is not a valid collective")
+          collective = main_collective
+        end
+
+        return collective
+      end
+
+      def interval
+        config.registerinterval
+      end
+
+      def publish(message)
+        unless message
+          Log.debug("Skipping registration due to nil body")
+        else
+          req = Message.new(message, nil, {:type => :request, :agent => "registration", :collective => target_collective, :filter => msg_filter})
+          req.encode!
+
+          Log.debug("Sending registration #{req.requestid} to collective #{req.collective}")
+
+          req.publish
+        end
+      end
+    end
+  end
+end

data/lib/mcollective/rpc.rb

@@ -0,0 +1,188 @@
+require 'pp'
+
+module MCollective
+  # 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
+  module RPC
+    autoload :Client, "mcollective/rpc/client"
+    autoload :Agent, "mcollective/rpc/agent"
+    autoload :Reply, "mcollective/rpc/reply"
+    autoload :Request, "mcollective/rpc/request"
+    autoload :Audit, "mcollective/rpc/audit"
+    autoload :Progress, "mcollective/rpc/progress"
+    autoload :Stats, "mcollective/rpc/stats"
+    autoload :DDL, "mcollective/rpc/ddl"
+    autoload :Result, "mcollective/rpc/result"
+    autoload :Helpers, "mcollective/rpc/helpers"
+    autoload :ActionRunner, "mcollective/rpc/actionrunner"
+
+    # Creates a standard options hash, pass in a block to add extra headings etc
+    # see Optionparser
+    def rpcoptions
+      oparser = MCollective::Optionparser.new({:verbose => false, :progress_bar => true}, "filter")
+
+      options = oparser.parse do |parser, options|
+        if block_given?
+          yield(parser, options)
+        end
+
+        Helpers.add_simplerpc_options(parser, options)
+      end
+
+      return options
+    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.
+    def rpcclient(agent, flags = {})
+      configfile = flags[:configfile] || "/etc/mcollective/client.cfg"
+      options = flags[:options] || nil
+
+      if flags.key?(:exit_on_failure)
+        exit_on_failure = flags[:exit_on_failure]
+      else
+        # We exit on failure by default for CLI-friendliness
+        exit_on_failure = true
+      end
+
+      begin
+        if options
+          rpc = Client.new(agent, :configfile => options[:config], :options => options)
+          @options = rpc.options
+        else
+          rpc = Client.new(agent, :configfile => configfile)
+          @options = rpc.options
+        end
+      rescue Exception => e
+        if exit_on_failure
+          puts("Could not create RPC client: #{e}")
+          exit!
+        else
+          raise e
+        end
+      end
+
+      if block_given?
+        yield(rpc)
+      else
+        return rpc
+      end
+    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.
+    def self.stats(stats)
+      @@stats = stats
+    end
+
+    # 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.
+    def self.discovered(discovered)
+      @@discovered = discovered
+    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
+    def printrpcstats(flags={})
+      return unless @options[:output_format] == :console
+
+      verbose = @options[:verbose] rescue verbose = false
+      caption = flags[:caption] || "rpc stats"
+
+      begin
+        stats = @@stats
+      rescue
+        puts("no stats to display")
+        return
+      end
+
+      puts
+      puts stats.report(caption, verbose)
+    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.
+    def printrpc(result, flags = {})
+      verbose = @options[:verbose] rescue verbose = false
+      verbose = flags[:verbose] || verbose
+      flatten = flags[:flatten] || false
+      format = @options[:output_format]
+
+      result_text =  Helpers.rpcresults(result, {:verbose => verbose, :flatten => flatten, :format => format})
+
+      if result.is_a?(Array) && format == :console
+        puts "\n%s\n" % [ result_text ]
+      else
+        # when we get just one result to print dont pad them all with
+        # blank spaces etc, just print the individual result with no
+        # padding
+        puts result_text unless result_text == ""
+      end
+    end
+
+    # Wrapper for MCollective::Util.empty_filter? to make clients less fugly
+    # to write - ticket #18
+    def empty_filter?(options)
+      if options.include?(:filter)
+        Util.empty_filter?(options[:filter])
+      else
+        Util.empty_filter?(options)
+      end
+    end
+
+    # Factory for RPC::Request messages, only really here to make agents
+    # a bit easier to understand
+    def self.request(msg)
+      RPC::Request.new(msg)
+    end
+
+    # Factory for RPC::Reply messages, only really here to make agents
+    # a bit easier to understand
+    def self.reply
+      RPC::Reply.new
+    end
+  end
+end