choria-mcorpc-support 0.0.1

data/lib/mcollective/pluginpackager/templates/debian/compat.erb

@@ -0,0 +1 @@
+7

data/lib/mcollective/pluginpackager/templates/debian/control.erb

@@ -0,0 +1,15 @@
+Source: <%= @package_name %>
+Homepage: <%= @plugin.metadata[:url] %>
+Section: utils
+Priority: extra
+Build-Depends: debhelper (>= 7), cdbs, dpatch
+Maintainer: <%= @plugin.metadata[:author] %>
+Standards-Version: 3.9.1
+<% @plugin.packagedata.each do |type, data| %>
+Package: <%= "#{@package_name}-#{type}" %>
+Architecture: all
+Depends: <%= build_dependency_string(data) %>
+Description: <%= @plugin.metadata[:description]%>
+ <%= data[:description]%>
+ .
+<% end -%>

data/lib/mcollective/pluginpackager/templates/debian/copyright.erb

@@ -0,0 +1,8 @@
+This package was generated by the MCollective plugin packager on
+<%= Time.now%>
+
+Upstream Author:
+  <%= @plugin.metadata[:author] %> <%= @plugin.metadata[:url] %>
+
+License:
+  <%= @plugin.metadata[:license] -%>

data/lib/mcollective/pluginpackager/templates/debian/rules.erb

@@ -0,0 +1,6 @@
+#!/usr/bin/make -f
+
+include /usr/share/cdbs/1/rules/debhelper.mk
+include /usr/share/cdbs/1/rules/dpatch.mk
+include /usr/share/cdbs/1/class/makefile.mk
+DEB_MAKE_INVOKE = $(DEB_MAKE_ENVVARS) make -f debian/Makefile -C $(DEB_BUILDDIR)

data/lib/mcollective/pluginpackager/templates/module/Modulefile.erb

@@ -0,0 +1,5 @@
+name '<%= @plugin.vendor %>-<%= @package_name %>'
+version '<%= @plugin.metadata[:version] %>'
+description '<%= @plugin.metadata[:description] %>'
+project_page '<%= @plugin.metadata[:url]%>'
+dependency 'puppetlabs/mcollective', '1.x'

data/lib/mcollective/pluginpackager/templates/module/README.md.erb

@@ -0,0 +1,37 @@
+# <%= @package_name %>
+
+#### Table of Contents
+
+1. [Overview](#overview)
+2. [Module Description - What the module does and why it is useful](#module-description)
+3. [Setup - The basics of getting started with <%= @package_name %>](#setup)
+    * [What the <%= @package_name %> module affects](#what-the-<%= @package_name %>-module-affects)
+    * [Setup requirements](#setup-requirements)
+4. [Usage - Configuration options and additional functionality](#usage)
+5. [Reference - An under-the-hood peek at what the module is doing and how](#reference)
+
+
+## Overview
+
+The <%= @package_name %> module is a module that wraps a source release of the
+<%= @plugin.metadata[:name] %> mcollective plugin for use with the
+[puppetlabs mcollective](http://forge.puppetlabs.com/puppetlabs/mcollective)
+module.
+
+## Module description
+
+## Usage
+
+<% @plugin.packagedata.keys.map { |x| x.to_s }.sort.each do |klass| -%>
+<%# Don't document common class -%>
+<% if klass != "common" -%>
+### class <%= @package_name %>::<%= klass %>
+
+Installs the <%= klass %> component of the <%= @plugin.metadata[:name] %> plugin.
+
+```puppet
+include <%= @package_name%>::<%= klass %>
+```
+<% end %>
+<% end %>
+

data/lib/mcollective/pluginpackager/templates/module/_manifest.pp.erb

@@ -0,0 +1,9 @@
+#
+class <%= @package_name %>::<%= @klass %> {
+  <% if @plugin.packagedata[:common] && @klass != 'common' %>
+  include ::<%= @package_name %>::common
+  <% end %>
+  mcollective::plugin { '<%= @package_name %>/<%= @klass %>':
+    source => 'puppet:///modules/<%= @package_name %>/<%= @klass %>',
+  }
+}

data/lib/mcollective/pluginpackager/templates/redhat/rpm_spec.erb

@@ -0,0 +1,63 @@
+Name: <%= @package_name %>
+Summary: <%= @plugin.metadata[:description] %>
+Version: <%= @plugin.metadata[:version] %>
+Release: <%= @plugin.revision %>%{?dist}
+License: <%= @plugin.metadata[:license]%>
+URL: <%= @plugin.metadata[:url]%>
+Vendor: <%= @plugin.vendor%>
+Packager: <%= @plugin.metadata[:author]%>
+BuildArch: noarch
+Group: System Tools
+BuildRoot: %{_tmppath}/%{name}-%{version}-%{release}-root-%(%{__id_u} -n)
+Source0: <%= @package_name_and_version%>.tgz
+
+%description
+<%= @plugin.metadata[:description] %>
+
+%prep
+%setup
+
+%build
+<% package_files = plugin_files.map{ |f| File.join(@libdir, File.expand_path(f).gsub(/#{File.expand_path(@plugin.path)}|\.\//, '')) } -%>
+<% dirs = package_files.map{ |f| File.dirname(f) }.uniq -%>
+
+%install
+rm -rf %{buildroot}
+<% dirs.each do |dir| -%>
+%{__install} -d -m0755 %{buildroot}<%= dir%>
+<% end -%>
+<% package_files.each do |file| -%>
+%{__install} -m0644 -v <%= (file[0].chr == '/') ? file[1..file.size-1]: file%> %{buildroot}<%=file %>
+<% end -%>
+
+<% @plugin.packagedata.each do |type, data| %>
+%package <%= type %>
+Summary: <%= @plugin.metadata[:description] %>
+<% if data[:plugindependency] %>
+Requires: <%= data[:plugindependency][:name] -%> = <%= data[:plugindependency][:version]%>-<%= data[:plugindependency][:revision]%>%{?dist}
+<% end -%>
+<% PluginPackager.filter_dependencies('redhat', data[:dependencies]).each do |dep|-%>
+Requires: <%= dep[:name] -%> <%= ">= #{dep[:version]}" if dep[:version]%><%="-#{dep[:revision]}" if dep[:revision]%>
+<% end -%>
+%description <%= type %>
+<%= data[:description] %>
+
+%files <%= type %>
+%defattr(-, root, root, -)
+<% package_files(data[:files]).each do |file| -%>
+<%= file %>
+<% end -%>
+<% end -%>
+
+<% if @plugin.preinstall -%>
+%pre
+<%= @plugin.preinstall %>
+<% end -%>
+<% if @plugin.postinstall -%>
+%post
+<%= @plugin.postinstall%>
+<% end -%>
+
+%changelog
+* <%= Time.now.strftime("%a %b %d %Y") -%> <%= @plugin.metadata[:author]%> - <%= @plugin.metadata[:version]%>-<%= @plugin.revision %>
+- Built Package <%= @plugin.metadata[:name] -%>

data/lib/mcollective/registration/base.rb

@@ -0,0 +1,91 @@
+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
+          publish_thread(connection)
+        end
+      end
+
+      def config
+        Config.instance
+      end
+
+      def msg_filter
+        filter = Util.empty_filter
+        filter["agent"] << "registration"
+        filter
+      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
+
+      def body
+        raise "Registration Plugins must implement the #body method"
+      end
+
+      private
+      def publish_thread(connnection)
+        if config.registration_splay
+            splay_delay = rand(interval)
+            Log.debug("registration_splay enabled. Registration will start in #{splay_delay} seconds")
+            sleep splay_delay
+          end
+
+          loop do
+            begin
+              publish(body)
+              sleep interval
+            rescue Exception => e
+              Log.error("Sending registration message failed: #{e}")
+              sleep interval
+            end
+          end
+      end
+    end
+  end
+end

data/lib/mcollective/rpc.rb

@@ -0,0 +1,182 @@
+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
+    require "mcollective/rpc/actionrunner"
+    require "mcollective/rpc/agent"
+    require "mcollective/rpc/audit"
+    require "mcollective/rpc/client"
+    require "mcollective/rpc/helpers"
+    require "mcollective/rpc/progress"
+    require "mcollective/rpc/reply"
+    require "mcollective/rpc/request"
+    require "mcollective/rpc/result"
+    require "mcollective/rpc/stats"
+
+    # 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] || Util.config_file_for_user
+      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:
+    #
+    #   printrpcstats :caption => "Foo", :summarize => true
+    #
+    # This will use "Foo" as the caption to the stats in verbose
+    # mode and print out any aggregate summary information if present
+    def printrpcstats(flags={})
+      return unless @options[:output_format] == :console
+
+      flags = {:summarize => false, :caption => "rpc stats"}.merge(flags)
+
+      verbose = @options[:verbose] rescue verbose = false
+
+      begin
+        stats = @@stats
+      rescue
+        puts("no stats to display")
+        return
+      end
+
+      puts stats.report(flags[:caption], flags[:summarize], 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]
+      forced_mode = @options[:force_display_mode] || false
+
+      result_text =  Helpers.rpcresults(result, {:verbose => verbose, :flatten => flatten, :format => format, :force_display_mode => forced_mode})
+
+      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
+
+    def self.const_missing(const_name)
+      super unless const_name == :DDL
+
+      Log.warn("MCollective::RPC::DDL is deprecatd, please use MCollective::DDL instead")
+      MCollective::DDL
+    end
+  end
+end

data/lib/mcollective/rpc/actionrunner.rb

@@ -0,0 +1,158 @@
+module MCollective
+  module RPC
+    # 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
+    class ActionRunner
+      attr_reader :command, :agent, :action, :format, :stdout, :stderr, :request
+
+      def initialize(command, request, format=:json)
+        @agent = request.agent
+        @action = request.action
+        @format = format
+        @request = request
+        @command = path_to_command(command)
+        @stdout = ""
+        @stderr = ""
+      end
+
+      def run
+        unless canrun?(command)
+          Log.warn("Cannot run #{to_s}")
+          raise RPCAborted, "Cannot execute #{to_s}"
+        end
+
+        Log.debug("Running #{to_s}")
+
+        request_file = saverequest(request)
+        reply_file = tempfile("reply")
+        reply_file.close
+
+        runner = shell(command, request_file.path, reply_file.path)
+
+        runner.runcommand
+
+        Log.debug("#{command} exited with #{runner.status.exitstatus}")
+
+        stderr.each_line {|l| Log.error("#{to_s}: #{l.chomp}")} unless stderr.empty?
+        stdout.each_line {|l| Log.info("#{to_s}: #{l.chomp}")} unless stdout.empty?
+
+        {:exitstatus => runner.status.exitstatus,
+         :stdout     => runner.stdout,
+         :stderr     => runner.stderr,
+         :data       => load_results(reply_file.path)}
+      ensure
+        request_file.close! if request_file.respond_to?("close!")
+        reply_file.close! if reply_file.respond_to?("close")
+      end
+
+      def shell(command, infile, outfile)
+        env = {"MCOLLECTIVE_REQUEST_FILE" => infile,
+               "MCOLLECTIVE_REPLY_FILE"   => outfile}
+
+        Shell.new("#{command} #{infile} #{outfile}", :cwd => Dir.tmpdir, :stdout => stdout, :stderr => stderr, :environment => env)
+      end
+
+      def load_results(file)
+        Log.debug("Attempting to load results in #{format} format from #{file}")
+
+        data = {}
+
+        if respond_to?("load_#{format}_results")
+          tempdata = send("load_#{format}_results", file)
+
+          tempdata.each_pair do |k,v|
+            data[k.to_sym] = v
+          end
+        end
+
+        data
+      rescue Exception => e
+        {}
+      end
+
+      def load_json_results(file)
+        return {} unless File.readable?(file)
+
+        JSON.load(File.read(file)) || {}
+      rescue JSON::ParserError
+        {}
+      end
+
+      def saverequest(req)
+        Log.debug("Attempting to save request in #{format} format")
+
+        if respond_to?("save_#{format}_request")
+          data = send("save_#{format}_request", req)
+
+          request_file = tempfile("request")
+          request_file.puts data
+          request_file.close
+        end
+
+        request_file
+      end
+
+      def save_json_request(req)
+        req.to_json
+      end
+
+      def canrun?(command)
+        File.executable?(command)
+      end
+
+      def to_s
+        "%s#%s command: %s" % [ agent, action, command ]
+      end
+
+      def tempfile(prefix)
+        Tempfile.new("mcollective_#{prefix}", Dir.tmpdir)
+      end
+
+      def path_to_command(command)
+        if Util.absolute_path?(command)
+          return command
+        end
+
+        Config.instance.libdir.each do |libdir|
+          command_file_old = File.join(libdir, "agent", agent, command)
+          command_file_new = File.join(libdir, "mcollective", "agent", agent, command)
+          command_file_old_exists = File.exists?(command_file_old)
+          command_file_new_exists = File.exists?(command_file_new)
+
+          if command_file_new_exists && command_file_old_exists
+            Log.debug("Found 'implemented_by' scripts found in two locations #{command_file_old} and #{command_file_new}")
+            Log.debug("Running script: #{command_file_new}")
+            return command_file_new
+          elsif command_file_old_exists
+            Log.debug("Running script: #{command_file_old}")
+            return command_file_old
+          elsif command_file_new_exists
+            Log.debug("Running script: #{command_file_new}")
+            return command_file_new
+          end
+        end
+
+        Log.warn("No script found for: #{command}")
+        command
+      end
+    end
+  end
+end