mcollective-client 1.3.3

data/lib/mcollective/connector.rb

@@ -0,0 +1,18 @@
+module MCollective
+  # Connectors take care of transporting messages between clients and agents,
+  # the design doesn't your middleware to be very rich in features.  All it
+  # really needs is the ability to send and receive messages to named queues/topics.
+  #
+  # At present there are assumptions about the naming of topics and queues that is
+  # compatible with Stomp, ie.
+  #
+  # /topic/foo.bar/baz
+  # /queue/foo.bar/baz
+  #
+  # This is the only naming format that is supported, but you could replace Stomp
+  # with something else that supports the above, see MCollective::Connector::Stomp
+  # for the default connector.
+  module Connector
+    autoload :Base, "mcollective/connector/base"
+  end
+end

data/lib/mcollective/connector/base.rb

@@ -0,0 +1,24 @@
+module MCollective
+  # Connector plugins handle the communications with the middleware, you can provide your own to speak
+  # to something other than Stomp, your plugins must inherit from MCollective::Connector::Base and should
+  # provide the following methods:
+  #
+  # connect       - Creates a connection to the middleware, no arguments should get its parameters from the config
+  # receive       - Receive data from the middleware, should act like a blocking call only returning if/when data
+  #                 was received.  It should get data from all subscribed channels/topics.  Individual messages
+  #                 should be returned as MCollective::Request objects with the payload provided
+  # publish       - Takes a target and msg, should send the message to the supplied target topic or destination
+  # subscribe     - Adds a subscription to a specific message source
+  # unsubscribe   - Removes a subscription to a specific message source
+  # disconnect    - Disconnects from the middleware
+  #
+  # These methods are all that's needed for a new connector protocol and should hopefully be simple
+  # enough to not have tied us to Stomp.
+  module Connector
+    class Base
+      def self.inherited(klass)
+        PluginManager << {:type => "connector_plugin", :class => klass.to_s}
+      end
+    end
+  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
+    autoload :Base, "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,86 @@
+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
+        @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
+
+        Thread.exclusive 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.clear
+
+              tfacts.each_pair do |key,value|
+                @facts[key.to_s] = value.to_s
+              end
+
+              @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
+    end
+  end
+end

data/lib/mcollective/log.rb

@@ -0,0 +1,103 @@
+module MCollective
+  # A simple class that allows logging at various levels.
+  class Log
+    class << self
+      @logger = nil
+
+      # Obtain the class name of the currently configured logger
+      def logger
+        @logger.class
+      end
+
+      # Logs at info level
+      def info(msg)
+        log(:info, msg)
+      end
+
+      # Logs at warn level
+      def warn(msg)
+        log(:warn, msg)
+      end
+
+      # Logs at debug level
+      def debug(msg)
+        log(:debug, msg)
+      end
+
+      # Logs at fatal level
+      def fatal(msg)
+        log(:fatal, msg)
+      end
+
+      # Logs at error level
+      def error(msg)
+        log(:error, msg)
+      end
+
+      # handle old code that relied on this class being a singleton
+      def instance
+        self
+      end
+
+      # increments the active log level
+      def cycle_level
+        @logger.cycle_level if @configured
+      end
+
+      # logs a message at a certain level
+      def log(level, msg)
+        configure unless @configured
+
+        raise "Unknown log level" unless [:error, :fatal, :debug, :warn, :info].include?(level)
+
+        if @logger
+          @logger.log(level, from, msg)
+        else
+          t = Time.new.strftime("%H:%M:%S")
+
+          STDERR.puts "#{t}: #{level}: #{from}: #{msg}"
+        end
+      end
+
+      # sets the logger class to use
+      def set_logger(logger)
+        @logger = logger
+      end
+
+      # configures the logger class, if the config has not yet been loaded
+      # we default to the console logging class and do not set @configured
+      # so that future calls to the log method will keep attempting to configure
+      # the logger till we eventually get a logging preference from the config
+      # module
+      def configure(logger=nil)
+        unless logger
+          logger_type = "console"
+
+          config = Config.instance
+
+          if config.configured
+            logger_type = config.logger_type
+            @configured = true
+          end
+
+          require "mcollective/logger/#{logger_type.downcase}_logger"
+          set_logger(eval("MCollective::Logger::#{logger_type.capitalize}_logger.new"))
+        else
+          set_logger(logger)
+          @configured = true
+        end
+
+
+        @logger.start
+      rescue Exception => e
+        @configured = false
+        STDERR.puts "Could not start logger: #{e.class} #{e}"
+      end
+
+      # figures out the filename that called us
+      def from
+        from = File.basename(caller[2])
+      end
+    end
+  end
+end

data/lib/mcollective/logger.rb

@@ -0,0 +1,5 @@
+module MCollective
+  module Logger
+    autoload :Base, "mcollective/logger/base"
+  end
+end

data/lib/mcollective/logger/base.rb

@@ -0,0 +1,73 @@
+module MCollective
+  module Logger
+    # A base class for logging providers.
+    #
+    # Logging providers should provide the following:
+    #
+    #    * start - all you need to do to setup your logging
+    #    * set_logging_level - set your logging to :info, :warn, etc
+    #    * valid_levels - a hash of maps from :info to your internal level name
+    #    * log - what needs to be done to log a specific message
+    class Base
+      attr_reader :active_level
+
+      def initialize
+        @known_levels = [:debug, :info, :warn, :error, :fatal]
+
+        # Sanity check the class that impliments the logging
+        @known_levels.each do |lvl|
+          raise "Logger class did not specify a map for #{lvl}" unless valid_levels.include?(lvl)
+        end
+      end
+
+      # Figures out the next level and sets it
+      def cycle_level
+        lvl = get_next_level
+        set_level(lvl)
+
+        log(lvl, "", "Logging level is now #{lvl.to_s.upcase}")
+      end
+
+      # Sets a new level and record it in @active_level
+      def set_level(level)
+        set_logging_level(level)
+        @active_level = level.to_sym
+      end
+
+      private
+      def map_level(level)
+        raise "Logger class do not know how to handle #{level} messages" unless valid_levels.include?(level.to_sym)
+
+        valid_levels[level.to_sym]
+      end
+
+      # Gets the next level in the list, cycles down to the firt once it reaches the end
+      def get_next_level
+        # if all else fails, always go to debug mode
+        nextlvl = :debug
+
+        if @known_levels.index(@active_level) == (@known_levels.size - 1)
+          nextlvl = @known_levels.first
+        else
+          idx = @known_levels.index(@active_level) + 1
+          nextlvl = @known_levels[idx]
+        end
+
+        nextlvl
+      end
+
+      # Abstract methods to ensure the logging implimentations supply what they should
+      def valid_levels
+        raise "The logging class did not supply a valid_levels method"
+      end
+
+      def log(level, from, msg)
+        raise "The logging class did not supply a log method"
+      end
+
+      def start
+        raise "The logging class did not supply a start method"
+      end
+    end
+  end
+end

data/lib/mcollective/logger/console_logger.rb

@@ -0,0 +1,61 @@
+module MCollective
+  module Logger
+    # Impliments a syslog based logger using the standard ruby syslog class
+    class Console_logger<Base
+      def start
+        set_level(:info)
+
+        config = Config.instance
+        set_level(config.loglevel.to_sym) if config.configured
+      end
+
+      def set_logging_level(level)
+        # nothing to do here, we ignore high levels when we log
+      end
+
+      def valid_levels
+        {:info  => :info,
+          :warn  => :warning,
+          :debug => :debug,
+          :fatal => :crit,
+          :error => :err}
+      end
+
+      def log(level, from, msg)
+        if @known_levels.index(level) >= @known_levels.index(@active_level)
+          time = Time.new.strftime("%Y/%m/%d %H:%M:%S")
+          lvltxt = colorize(level, level)
+          STDERR.puts("#{lvltxt} #{time}: #{from} #{msg}")
+        end
+      rescue
+        # if this fails we probably cant show the user output at all,
+        # STDERR it as last resort
+        STDERR.puts("#{level}: #{msg}")
+      end
+
+      # Set some colors for various logging levels, will honor the
+      # color configuration option and return nothing if its configured
+      # not to
+      def color(level)
+        colorize = Config.instance.color
+
+        colors = {:error => "",
+          :fatal => "",
+          :warn => "",
+          :info => "",
+          :reset => ""}
+
+        if colorize
+          return colors[level] || ""
+        else
+          return ""
+        end
+      end
+
+      # Helper to return a string in specific color
+      def colorize(level, msg)
+        "#{self.color(level)}#{msg}#{self.color(:reset)}"
+      end
+    end
+  end
+end

data/lib/mcollective/logger/file_logger.rb

@@ -0,0 +1,46 @@
+require 'logger'
+
+module MCollective
+  module Logger
+    # Impliments a file based logger using the standard ruby logger class
+    #
+    # To configure you should set:
+    #
+    #   - config.logfile
+    #   - config.keeplogs defaults to 2097152
+    #   - config.max_log_size defaults to 5
+    class File_logger<Base
+      def start
+        config = Config.instance
+
+        @logger = ::Logger.new(config.logfile, config.keeplogs, config.max_log_size)
+        @logger.formatter = ::Logger::Formatter.new
+
+        set_level(config.loglevel.to_sym)
+      end
+
+      def set_logging_level(level)
+        @logger.level = map_level(level)
+      rescue Exception => e
+        @logger.level = ::Logger::DEBUG
+        log(:error, "", "Could not set logging to #{level} using debug instead: #{e.class} #{e}")
+      end
+
+      def valid_levels
+        {:info  => ::Logger::INFO,
+          :warn  => ::Logger::WARN,
+          :debug => ::Logger::DEBUG,
+          :fatal => ::Logger::FATAL,
+          :error => ::Logger::ERROR}
+      end
+
+      def log(level, from, msg)
+        @logger.add(map_level(level)) { "#{from} #{msg}" }
+      rescue
+        # if this fails we probably cant show the user output at all,
+        # STDERR it as last resort
+        STDERR.puts("#{level}: #{msg}")
+      end
+    end
+  end
+end