choria-mcorpc-support 0.0.1

data/lib/mcollective/discovery/flatfile.ddl

@@ -0,0 +1,11 @@
+metadata    :name        => "flatfile",
+            :description => "Flatfile based discovery for node identities",
+            :author      => "R.I.Pienaar <rip@devco.net>",
+            :license     => "ASL 2.0",
+            :version     => "0.1",
+            :url         => "https://docs.puppetlabs.com/mcollective/",
+            :timeout     => 0
+
+discovery do
+    capabilities :identity
+end

data/lib/mcollective/discovery/flatfile.rb

@@ -0,0 +1,48 @@
+# discovers against a flatfile instead of the traditional network discovery
+# the flat file must have a node name per line which should match identities
+# as configured
+module MCollective
+  class Discovery
+    class Flatfile
+      def self.discover(filter, timeout, limit=0, client=nil)
+        unless client.options[:discovery_options].empty?
+          file = client.options[:discovery_options].first
+        else
+          raise "The flatfile discovery method needs a path to a text file"
+        end
+
+        raise "Cannot read the file %s specified as discovery source" % file unless File.readable?(file)
+
+        discovered = []
+        hosts = []
+
+        File.readlines(file).each do |host|
+          host = host.chomp.strip
+          if host.empty? || host.match(/^#/)
+            next
+          end
+          raise 'Identities can only match /^[\w\.\-]+$/' unless host.match(/^[\w\.\-]+$/)
+          hosts << host
+        end
+
+        # this plugin only supports identity filters, do regex matches etc against
+        # the list found in the flatfile
+        if !(filter["identity"].empty?)
+          filter["identity"].each do |identity|
+            identity = Regexp.new(identity.gsub("\/", "")) if identity.match("^/")
+
+            if identity.is_a?(Regexp)
+              discovered = hosts.grep(identity)
+            elsif hosts.include?(identity)
+              discovered << identity
+            end
+          end
+        else
+          discovered = hosts
+        end
+
+        discovered
+      end
+    end
+  end
+end

data/lib/mcollective/discovery/mc.ddl

@@ -0,0 +1,11 @@
+metadata    :name        => "mc",
+            :description => "MCollective Broadcast based discovery",
+            :author      => "R.I.Pienaar <rip@devco.net>",
+            :license     => "ASL 2.0",
+            :version     => "0.1",
+            :url         => "https://docs.puppetlabs.com/mcollective/",
+            :timeout     => 2
+
+discovery do
+    capabilities [:classes, :facts, :identity, :agents, :compound]
+end

data/lib/mcollective/discovery/mc.rb

@@ -0,0 +1,30 @@
+module MCollective
+  class Discovery
+    class Mc
+      def self.discover(filter, timeout, limit, client)
+        begin
+          hosts = []
+          Timeout.timeout(timeout) do
+            reqid = client.sendreq("ping", "discovery", filter)
+            Log.debug("Waiting #{timeout} seconds for discovery replies to request #{reqid}")
+
+            loop do
+              reply = client.receive(reqid)
+              Log.debug("Got discovery reply from #{reply.payload[:senderid]}")
+              hosts << reply.payload[:senderid]
+
+              return hosts if limit > 0 && hosts.size == limit
+            end
+          end
+        rescue Timeout::Error => e
+        rescue Exception => e
+          raise
+        ensure
+          client.unsubscribe("discovery", :reply)
+        end
+
+        hosts
+      end
+    end
+  end
+end

data/lib/mcollective/discovery/stdin.ddl

@@ -0,0 +1,11 @@
+metadata    :name        => "stdin",
+            :description => "STDIN based discovery for node identities",
+            :author      => "Tomas Doran <bobtfish@bobtfish.net.net>",
+            :license     => "ASL 2.0",
+            :version     => "0.1",
+            :url         => "https://docs.puppetlabs.com/mcollective/",
+            :timeout     => 0
+
+discovery do
+    capabilities :identity
+end

data/lib/mcollective/discovery/stdin.rb

@@ -0,0 +1,68 @@
+# discovers against stdin instead of the traditional network discovery
+# the input must be a flat file with a node name per line which should match identities as configured,
+# or it should be a json string as output by the -j option of mco rpc
+require 'mcollective/rpc/helpers'
+
+module MCollective
+  class Discovery
+    class Stdin
+      def self.discover(filter, timeout, limit=0, client=nil)
+        unless client.options[:discovery_options].empty?
+          type = client.options[:discovery_options].first.downcase
+        else
+          type = 'auto'
+        end
+
+        discovered = []
+
+        file = STDIN.read
+
+        if file =~ /^\s*$/
+          raise("data piped on STDIN contained only whitespace - could not discover hosts from it.")
+        end
+
+        if type == 'auto'
+          if file =~ /^\s*\[/
+            type = 'json'
+          else
+            type = 'text'
+          end
+        end
+
+        Log.debug("Parsing STDIN input as type %s" % type)
+
+        if type == 'json'
+          hosts = RPC::Helpers.extract_hosts_from_json(file)
+        elsif type == 'text'
+          hosts = file.split("\n")
+        else
+          raise("stdin discovery plugin only knows the types auto/text/json, not \"#{type}\"")
+        end
+
+        hosts.map do |host|
+          raise 'Identities can only match /\w\.\-/' unless host.match(/^[\w\.\-]+$/)
+          host
+        end
+
+        # this plugin only supports identity filters, do regex matches etc against
+        # the list found in the flatfile
+        unless filter["identity"].empty?
+          filter["identity"].each do |identity|
+            identity = Regexp.new(identity.gsub("\/", "")) if identity.match("^/")
+
+            if identity.is_a?(Regexp)
+              discovered = hosts.grep(identity)
+            elsif hosts.include?(identity)
+              discovered << identity
+            end
+          end
+        else
+          discovered = hosts
+        end
+
+        discovered
+      end
+    end
+  end
+end
+

data/lib/mcollective/exceptions.rb

@@ -0,0 +1,28 @@
+module MCollective
+# Exceptions for the RPC system
+  class DDLValidationError<RuntimeError;end
+  class ValidatorError<RuntimeError; end
+  class ClientTimeoutError<RuntimeError; end
+  class MsgDoesNotMatchRequestID < RuntimeError; end
+  class MsgTTLExpired<RuntimeError;end
+  class NotTargettedAtUs<RuntimeError;end
+  class RPCError<StandardError;end
+  class SecurityValidationFailed<RuntimeError;end
+
+  class BackoffSuggestion<StandardError
+    attr_reader :backoff
+
+    def initialize(backoff = nil)
+      @backoff = backoff
+    end
+  end
+
+  class MessageNotReceived<BackoffSuggestion; end
+  class UnexpectedMessageType<BackoffSuggestion; end
+
+  class InvalidRPCData<RPCError;end
+  class MissingRPCData<RPCError;end
+  class RPCAborted<RPCError;end
+  class UnknownRPCAction<RPCError;end
+  class UnknownRPCError<RPCError;end
+end

data/lib/mcollective/facts.rb

@@ -0,0 +1,39 @@
+module MCollective
+  # 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.
+  module Facts
+    require "mcollective/facts/base"
+
+    @@config = nil
+
+    # True if we know of a specific fact else false
+    def self.has_fact?(fact, value)
+      PluginManager["facts_plugin"].get_fact(fact) == value ? true : false
+    end
+
+    # Get the value of a fact
+    def self.get_fact(fact)
+      PluginManager["facts_plugin"].get_fact(fact)
+    end
+
+    # Get the value of a fact
+    def self.[](fact)
+      PluginManager["facts_plugin"].get_fact(fact)
+    end
+  end
+end

data/lib/mcollective/facts/base.rb

@@ -0,0 +1,100 @@
+module MCollective
+  module Facts
+    # 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"}
+    class Base
+      def initialize
+        @mutex = Mutex.new
+        @facts = {}
+        @last_good_facts = {}
+        @last_facts_load = 0
+      end
+
+      # Registers new fact sources into the plugin manager
+      def self.inherited(klass)
+        PluginManager << {:type => "facts_plugin", :class => klass.to_s}
+      end
+
+      # Returns the value of a single fact
+      def get_fact(fact=nil)
+        config = Config.instance
+
+        cache_time = config.fact_cache_time || 300
+
+        @mutex.synchronize do
+          begin
+            if (Time.now.to_i - @last_facts_load > cache_time.to_i ) || force_reload?
+              Log.debug("Resetting facter cache, now: #{Time.now.to_i} last-known-good: #{@last_facts_load}")
+
+              tfacts = load_facts_from_source
+
+              # Force reset to last known good state on empty facts
+              raise "Got empty facts" if tfacts.empty?
+
+              @facts = normalize_facts(tfacts)
+
+              @last_good_facts = @facts.clone
+              @last_facts_load = Time.now.to_i
+            else
+              Log.debug("Using cached facts now: #{Time.now.to_i} last-known-good: #{@last_facts_load}")
+            end
+          rescue Exception => e
+            Log.error("Failed to load facts: #{e.class}: #{e}")
+
+            # Avoid loops where failing fact loads cause huge CPU
+            # loops, this way it only retries once every cache_time
+            # seconds
+            @last_facts_load = Time.now.to_i
+
+            # Revert to last known good state
+            @facts = @last_good_facts.clone
+          end
+        end
+
+
+        # If you do not supply a specific fact all facts will be returned
+        if fact.nil?
+          return @facts
+        else
+          @facts.include?(fact) ? @facts[fact] : nil
+        end
+      end
+
+      # Returns all facts
+      def get_facts
+        get_fact(nil)
+      end
+
+      # Returns true if we know about a specific fact, false otherwise
+      def has_fact?(fact)
+        get_fact(nil).include?(fact)
+      end
+
+      # Plugins can override this to provide forced fact invalidation
+      def force_reload?
+        false
+      end
+
+      private
+
+      def normalize_facts(value)
+        case value
+        when Array
+          return value.map { |v| normalize_facts(v) }
+        when Hash
+          new_hash = {}
+          value.each do |k,v|
+            new_hash[k.to_s] = normalize_facts(v)
+          end
+          return new_hash
+        else
+          return value.to_s
+        end
+      end
+    end
+  end
+end

data/lib/mcollective/facts/yaml_facts.rb

@@ -0,0 +1,65 @@
+module MCollective
+  module Facts
+    require 'yaml'
+
+    # A factsource that reads a hash of facts from a YAML file
+    #
+    # Multiple files can be specified seperated with a : in the
+    # config file, they will be merged with later files overriding
+    # earlier ones in the list.
+    class Yaml_facts<Base
+      def initialize
+        @yaml_file_mtimes = {}
+
+        super
+      end
+
+      def load_facts_from_source
+        config = Config.instance
+
+        fact_files = config.pluginconf["yaml"].split(File::PATH_SEPARATOR)
+        facts = {}
+
+        fact_files.each do |file|
+          begin
+            if File.exist?(file)
+	      if YAML.respond_to? :safe_load
+                facts.merge!(YAML.safe_load(File.read(file))) 
+	      else
+                facts.merge!(YAML.load(File.read(file)))  # rubocop:disable Security/YAMLLoad
+              end
+            else
+              raise("Can't find YAML file to load: #{file}")
+            end
+          rescue Exception => e
+            Log.error("Failed to load yaml facts from #{file}: #{e.class}: #{e}")
+          end
+        end
+
+        facts
+      end
+
+      # force fact reloads when the mtime on the yaml file change
+      def force_reload?
+        config = Config.instance
+
+        fact_files = config.pluginconf["yaml"].split(File::PATH_SEPARATOR)
+
+        fact_files.each do |file|
+          @yaml_file_mtimes[file] ||= File.stat(file).mtime
+          mtime = File.stat(file).mtime
+
+          if mtime > @yaml_file_mtimes[file]
+            @yaml_file_mtimes[file] = mtime
+
+            Log.debug("Forcing fact reload due to age of #{file}")
+
+            return true
+          end
+        end
+
+        false
+      end
+    end
+  end
+end

data/lib/mcollective/generators.rb

@@ -0,0 +1,7 @@
+module MCollective
+  module Generators
+    require "mcollective/generators/base.rb"
+    require "mcollective/generators/data_generator.rb"
+    require "mcollective/generators/agent_generator.rb"
+  end
+end

data/lib/mcollective/generators/agent_generator.rb

@@ -0,0 +1,51 @@
+module MCollective
+  module Generators
+    class AgentGenerator<Base
+
+      attr_accessor :ddl, :content
+
+      def initialize(plugin_name, actions = [],  name = nil, description = nil, author = nil ,
+                     license = nil, version = nil, url = nil, timeout = nil)
+
+        super(name, description, author, license, version, url, timeout)
+        @plugin_name = plugin_name
+        @actions = actions || []
+        @ddl = create_ddl
+        @mod_name = "Agent"
+        @pclass = "RPC::Agent"
+        @content = create_plugin_content
+        @plugin = create_plugin_string
+        write_plugins
+      end
+
+      def create_ddl
+        action_text = ""
+        @actions.each_with_index do |action, i|
+          action_text += "action \"#{action}\", :description => \"%ACTIONDESCRIPTION%\" do\n"
+          action_text += action_help if i == 0
+          action_text += "end\n"
+          action_text += "\n" unless @actions.size == (i + 1)
+        end
+        # Use inherited method to create metadata part of the ddl
+        create_metadata_string + action_text
+      end
+
+      def create_plugin_content
+        content_text = ""
+
+        # Add actions to agent file
+        @actions.each_with_index do |action, i|
+          content_text +=  "%6s%s" % [" ", "action \"#{action}\" do\n"]
+          content_text +=  "%6s%s" % [" ", "end\n"]
+          content_text += "\n" unless @actions.size == (i + 1)
+        end
+        content_text
+      end
+
+      def action_help
+        action_snippet = File.read(File.join(File.dirname(__FILE__), "templates", "action_snippet.erb"))
+        ERB.new(action_snippet).result
+      end
+    end
+  end
+end