choria-mcorpc-support 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 6ae1643132a522cc95d0ca2aa305795d0339a552
+  data.tar.gz: 3bb0890088ba7f874d81df9ea7dc494f2a9ab485
+SHA512:
+  metadata.gz: d6b85252e78fe6d90b2c269ca47b06879a963e9108f16170061d05a5da18ac5ccc388a98cfd52a59e1c3360806174dfcbc46bb2409e3814a6c1efc503a9cb788
+  data.tar.gz: b09baf095839b1915238661d5bd4ea5430b780318cae53c77bea645a3a23c3b21d3d986da3e25d920d220366961931a23ba59d1fc781c492db2fcead4d2168f5

data/bin/mco

@@ -0,0 +1,64 @@
+#!/usr/bin/env ruby
+
+# For security reasons, ensure that '.' is not on the load path
+# This is primarily for 1.8.7 since 1.9.2+ doesn't put '.' on the load path
+$LOAD_PATH.delete '.'
+
+require 'mcollective'
+
+# assume everything will all be fine
+exitcode = 0
+
+Version = MCollective.version
+known_applications = MCollective::Applications.list
+
+# links from mc-ping to mc will result in ping being run
+if $0 =~ /mc\-([a-zA-Z\-_\.]+)$/
+  app_name = $1
+else
+  app_name = ARGV.first
+  ARGV.delete_at(0)
+
+  # it may be a config option rather than an application name.  In this
+  # case pretend we had no application name
+  if app_name =~ /^--/
+    app_name = nil
+  end
+end
+
+if known_applications.include?(app_name)
+  # make sure the various options classes shows the right help etc
+  $0 = app_name
+
+  MCollective::Applications.run(app_name)
+else
+  puts "The Marionette Collective version #{MCollective.version}"
+  puts
+
+  if app_name
+    puts "Unknown command '#{app_name}', searched for applications in:"
+    puts
+    puts MCollective::Config.instance.libdir.map { |path| "   #{path}\n" }
+    puts
+
+    # exit with an error as we didn't find a command
+    exitcode = 1
+  else
+    puts "usage: #{$0} command <options>"
+    puts
+  end
+
+  puts "Known commands:"
+  puts
+
+  known_applications.sort.uniq.in_groups_of(3) do |apps|
+    puts "   %-20s %-20s %-20s" % [apps[0], apps[1], apps[2]]
+  end
+
+  puts
+  puts "Type '#{$0} help' for a detailed list of commands and '#{$0} help command'"
+  puts "to get detailed help for a command"
+  puts
+end
+
+exit exitcode

data/lib/mcollective.rb

@@ -0,0 +1,63 @@
+require 'rubygems'
+require 'json'
+require 'timeout'
+require 'digest/md5'
+require 'optparse'
+require 'singleton'
+require 'socket'
+require 'erb'
+require 'shellwords'
+require 'stringio'
+require 'rbconfig'
+require 'tempfile'
+require 'tmpdir'
+require 'mcollective/monkey_patches'
+require 'mcollective/cache'
+require 'mcollective/exceptions'
+require 'systemu'
+
+# == The Marionette Collective
+#
+# 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
+module MCollective
+
+  require "mcollective/agent"
+  require "mcollective/agents"
+  require "mcollective/aggregate"
+  require "mcollective/application"
+  require "mcollective/applications"
+  require "mcollective/client"
+  require "mcollective/config"
+  require "mcollective/connector"
+  require "mcollective/data"
+  require "mcollective/ddl"
+  require "mcollective/discovery"
+  require "mcollective/facts"
+  require "mcollective/logger"
+  require "mcollective/log"
+  require "mcollective/matcher"
+  require "mcollective/message"
+  require "mcollective/optionparser"
+  require "mcollective/generators"
+  require "mcollective/pluginmanager"
+  require "mcollective/pluginpackager"
+  require "mcollective/rpc"
+  require "mcollective/runnerstats"
+  require "mcollective/security"
+  require "mcollective/shell"
+  require "mcollective/ssl"
+  require "mcollective/util"
+  require "mcollective/validator"
+
+  VERSION="2.20.0"
+
+  def self.version
+    VERSION
+  end
+end

data/lib/mcollective/agent.rb

@@ -0,0 +1,5 @@
+module MCollective
+  module Agent
+
+  end
+end

data/lib/mcollective/agents.rb

@@ -0,0 +1,149 @@
+module MCollective
+  # 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.
+  class Agents
+    def initialize(agents = {})
+      @config = Config.instance
+      raise ("Configuration has not been loaded, can't load agents") unless @config.configured
+
+      @@agents = agents
+
+      loadagents
+    end
+
+    # Deletes all agents
+    def clear!
+      @@agents.each_key do |agent|
+        PluginManager.delete "#{agent}_agent"
+        Util.unsubscribe(Util.make_subscriptions(agent, :broadcast))
+      end
+
+      @@agents = {}
+    end
+
+    # Loads all agents from disk
+    def loadagents
+      Log.debug("Reloading all agents from disk")
+
+      clear!
+
+      @config.libdir.each do |libdir|
+        agentdir = "#{libdir}/mcollective/agent"
+        next unless File.directory?(agentdir)
+
+        Dir.new(agentdir).grep(/\.rb$/).each do |agent|
+          agentname = File.basename(agent, ".rb")
+          loadagent(agentname) unless PluginManager.include?("#{agentname}_agent")
+        end
+      end
+    end
+
+    # Loads a specified agent from disk if available
+    def loadagent(agentname)
+      agentfile = findagentfile(agentname)
+      return false unless agentfile
+      classname = class_for_agent(agentname)
+
+      PluginManager.delete("#{agentname}_agent")
+
+      begin
+        single_instance = ["registration", "discovery"].include?(agentname)
+
+        PluginManager.loadclass(classname)
+
+        if activate_agent?(agentname)
+          PluginManager << {:type => "#{agentname}_agent", :class => classname, :single_instance => single_instance}
+
+          # Attempt to instantiate the agent once so any validation and hooks get run
+          # this does a basic sanity check on the agent as a whole, if this fails it
+          # will be removed from the plugin list
+          PluginManager["#{agentname}_agent"]
+
+          Util.subscribe(Util.make_subscriptions(agentname, :broadcast)) unless @@agents.include?(agentname)
+
+          @@agents[agentname] = {:file => agentfile}
+          return true
+        else
+          Log.debug("Not activating agent #{agentname} due to agent policy in activate? method")
+          return false
+        end
+      rescue Exception => e
+        Log.error("Loading agent #{agentname} failed: #{e}")
+        PluginManager.delete("#{agentname}_agent")
+        return false
+      end
+    end
+
+    # Builds a class name string given a Agent name
+    def class_for_agent(agent)
+      "MCollective::Agent::#{agent.capitalize}"
+    end
+
+    # Checks if a plugin should be activated by
+    # calling #activate? on it if it responds to
+    # that method else always activate it
+    def activate_agent?(agent)
+      klass = Kernel.const_get("MCollective").const_get("Agent").const_get(agent.capitalize)
+
+      if klass.respond_to?("activate?")
+        return klass.activate?
+      else
+        Log.debug("#{klass} does not have an activate? method, activating as default")
+        return true
+      end
+    rescue Exception => e
+      Log.warn("Agent activation check for #{agent} failed: #{e.class}: #{e}")
+      return false
+    end
+
+    # searches the libdirs for agents
+    def findagentfile(agentname)
+      @config.libdir.each do |libdir|
+        agentfile = File.join([libdir, "mcollective", "agent", "#{agentname}.rb"])
+        if File.exist?(agentfile)
+          Log.debug("Found #{agentname} at #{agentfile}")
+          return agentfile
+        end
+      end
+      return false
+    end
+
+    # Determines if we have an agent with a certain name
+    def include?(agentname)
+      PluginManager.include?("#{agentname}_agent")
+    end
+
+    # Dispatches a message to an agent, accepts a block that will get run if there are
+    # any replies to process from the agent
+    def dispatch(request, connection)
+      Log.debug("Dispatching a message to agent #{request.agent}")
+
+      Thread.new do
+        begin
+          agent = PluginManager["#{request.agent}_agent"]
+
+          Timeout::timeout(agent.timeout) do
+            replies = agent.handlemsg(request.payload, connection)
+
+            # Agents can decide if they wish to reply or not,
+            # returning nil will mean nothing goes back to the
+            # requestor
+            unless replies == nil
+              yield(replies)
+            end
+          end
+        rescue Timeout::Error => e
+          Log.warn("Timeout while handling message for #{request.agent}")
+        rescue Exception => e
+          Log.error("Execution of #{request.agent} failed: #{e}")
+          Log.error(e.backtrace.join("\n\t\t"))
+        end
+      end
+    end
+
+    # Get a list of agents that we have
+    def self.agentlist
+      @@agents.keys
+    end
+  end
+end

data/lib/mcollective/aggregate.rb

@@ -0,0 +1,85 @@
+module MCollective
+  class Aggregate
+    require 'mcollective/aggregate/result'
+    require 'mcollective/aggregate/base'
+
+    attr_accessor :ddl, :functions, :action, :failed
+
+    def initialize(ddl)
+      @functions = []
+      @ddl = ddl
+      @action = ddl[:action]
+      @failed = []
+
+      create_functions
+    end
+
+    # Creates instances of the Aggregate functions and stores them in the function array.
+    # All aggregate call and summarize method calls operate on these function as a batch.
+    def create_functions
+      @ddl[:aggregate].each_with_index do |agg, i|
+        output = agg[:args][0]
+
+        if contains_output?(output)
+          arguments = agg[:args][1]
+          format = (arguments.delete(:format) if arguments) || nil
+          begin
+            @functions << load_function(agg[:function]).new(output, arguments, format, @action)
+          rescue Exception => e
+            Log.error("Cannot create aggregate function '#{output}'. #{e.to_s}")
+            @failed << {:name => output, :type => :startup}
+          end
+        else
+          Log.error("Cannot create aggregate function '#{output}'. '#{output}' has not been specified as a valid ddl output.")
+          @failed << {:name => output, :type => :create}
+        end
+      end
+    end
+
+    # Check if the function param is defined as an output for the action in the ddl
+    def contains_output?(output)
+      @ddl[:output].keys.include?(output)
+    end
+
+    # Call all the appropriate functions with the reply data received from RPC::Client
+    def call_functions(reply)
+      @functions.each do |function|
+        Log.debug("Calling aggregate function #{function} for result")
+        begin
+          function.process_result(reply[:data][function.output_name], reply)
+        rescue Exception => e
+          Log.error("Could not process aggregate function for '#{function.output_name}'. #{e.to_s}")
+          @failed << {:name => function.output_name, :type => :process_result}
+          @functions.delete(function)
+        end
+      end
+    end
+
+    # Finalizes the function returning a result object
+    def summarize
+      summary = @functions.map do |function|
+        begin
+          function.summarize
+        rescue Exception => e
+          Log.error("Could not summarize aggregate result for '#{function.output_name}'. #{e.to_s}")
+          @failed << {:name => function.output_name, :type => :summarize}
+          nil
+        end
+      end
+
+      summary.reject{|x| x.nil?}.sort do |x,y|
+        x.result[:output] <=> y.result[:output]
+      end
+    end
+
+    # Loads function from disk for use
+    def load_function(function_name)
+      function_name = function_name.to_s.capitalize
+
+      PluginManager.loadclass("MCollective::Aggregate::#{function_name}") unless Aggregate.const_defined?(function_name)
+      Aggregate.const_get(function_name)
+    rescue Exception
+      raise "Aggregate function file '#{function_name.downcase}.rb' cannot be loaded"
+    end
+  end
+end

data/lib/mcollective/aggregate/average.ddl

@@ -0,0 +1,33 @@
+metadata  :name        => "average",
+          :description => "Displays the average of a set of numeric values",
+          :author      => "Pieter Loubser <pieter.loubser@puppetlabs.com>",
+          :license     => "ASL 2.0",
+          :version     => "1.0",
+          :url         => "https://docs.puppetlabs.com/mcollective/plugin_directory/",
+          :timeout     => 5
+
+usage <<-USAGE
+
+  This aggregate plugin will determine the average of a set of numeric values.
+
+  DDL Example:
+
+    summarize do
+      aggregate average(:value)
+    end
+
+  Sample Output:
+
+    host1.example.com
+      Value: 10
+
+    host2.example.com
+      Value: 20
+
+
+   Summary of Value:
+
+      Average of Value: 15.000000
+
+USAGE
+

data/lib/mcollective/aggregate/average.rb

@@ -0,0 +1,29 @@
+module MCollective
+  class Aggregate
+    class Average<Base
+      # Before function is run processing
+      def startup_hook
+        @result[:value] = 0
+        @result[:type] = :numeric
+
+        @count = 0
+
+        # Set default aggregate_function if it is undefined
+        @aggregate_format = "Average of #{@result[:output]}: %f" unless @aggregate_format
+      end
+
+      # Determines the average of a set of numerical values
+      def process_result(value, reply)
+        @result[:value] += value
+        @count += 1
+      end
+
+      # Stops execution of the function and returns a ResultObject
+      def summarize
+        @result[:value] /= @count
+
+        result_class(:numeric).new(@result, @aggregate_format, @action)
+      end
+    end
+  end
+end