choria-mcorpc-support 0.0.1

data/lib/mcollective/generators/base.rb

@@ -0,0 +1,46 @@
+module MCollective
+  module Generators
+    class Base
+      attr_accessor :meta, :plugin_name, :mod_name
+      def initialize(name, description, author, license, version, url, timeout)
+        @meta = {:name => name,
+                 :description => description,
+                 :author => author,
+                 :license => license,
+                 :version => version,
+                 :url => url,
+                 :timeout => timeout}
+      end
+
+      def create_metadata_string
+        ddl_template = File.read(File.join(File.dirname(__FILE__), "templates", "ddl.erb"))
+        ERB.new(ddl_template, nil, "-").result(binding)
+      end
+
+      def create_plugin_string
+        plugin_template = File.read(File.join(File.dirname(__FILE__), "templates", "plugin.erb"))
+        ERB.new(plugin_template, nil, "-").result(binding)
+      end
+
+      def write_plugins
+        begin
+          Dir.mkdir @plugin_name
+          dirname = File.join(@plugin_name, @mod_name.downcase)
+          Dir.mkdir dirname
+          puts "Created plugin directory : #{@plugin_name}"
+
+          File.open(File.join(dirname, "#{@plugin_name}.ddl"), "w"){|f| f.puts @ddl}
+          puts "Created DDL file : #{File.join(dirname, "#{@plugin_name}.ddl")}"
+
+          File.open(File.join(dirname, "#{@plugin_name}.rb"), "w"){|f| f.puts @plugin}
+          puts "Created #{@mod_name} file : #{File.join(dirname, "#{@plugin_name}.rb")}"
+        rescue Errno::EEXIST
+          raise "cannot generate '#{@plugin_name}' : plugin directory already exists."
+        rescue Exception => e
+          FileUtils.rm_rf(@plugin_name) if File.directory?(@plugin_name)
+          raise "cannot generate plugin - #{e}"
+        end
+      end
+    end
+  end
+end

data/lib/mcollective/generators/data_generator.rb

@@ -0,0 +1,51 @@
+module MCollective
+  module Generators
+    class DataGenerator<Base
+
+      attr_accessor :ddl, :content
+
+      def initialize(plugin_name, outputs = [],  name = nil, description = nil, author = nil ,
+                     license = nil, version = nil, url = nil, timeout = nil)
+
+        super(name, description, author, license, version, url, timeout)
+        @mod_name = "Data"
+        @pclass = "Base"
+        @plugin_name = plugin_name
+        @outputs = outputs
+        @ddl = create_ddl
+        @content = create_plugin_content
+        @plugin = create_plugin_string
+        write_plugins
+      end
+
+      def create_ddl
+        query_text = "dataquery :description => \"Query information\" do\n"
+        query_text += ERB.new(File.read(File.join(File.dirname(__FILE__), "templates", "data_input_snippet.erb"))).result
+
+        @outputs.each_with_index do |output,i|
+          query_text += "%2s%s" % [" ", "output :#{output},\n"]
+          query_text += "%9s%s" % [" ", ":description => \"%DESCRIPTION%\",\n"]
+          query_text += "%9s%s" % [" ", ":display_as => \"%DESCRIPTION%\"\n"]
+          query_text += "\n" unless @outputs.size == (i + 1)
+        end
+
+        query_text += "end"
+
+        # Use inherited method to create metadata part of the ddl
+        create_metadata_string + query_text
+      end
+
+      def create_plugin_content
+        content_text = "%6s%s" % [" ", "query do |what|\n"]
+
+        @outputs.each do |output|
+           content_text += "%8s%s" % [" ", "result[:#{output}] = nil\n"]
+        end
+        content_text += "%6s%s" % [" ", "end\n"]
+
+        # Add actions to agent file
+        content_text
+      end
+    end
+  end
+end

data/lib/mcollective/generators/templates/action_snippet.erb

@@ -0,0 +1,13 @@
+     # Example Input
+     input :name,
+           :prompt => "%PROMPT%",
+           :description => "%DESCRIPTION%",
+           :type => %TYPE%,
+           :validation => '%VALIDATION%',
+           :optional => %OPTIONAL%,
+           :maxlength => %MAXLENGTH%
+
+     # Example output
+     output :name,
+            :description => "%DESCRIPTION%",
+            :display_as => "%DISPLAYAS%"

data/lib/mcollective/generators/templates/data_input_snippet.erb

@@ -0,0 +1,7 @@
+  input :query,
+        :prompt => "%PROMP%",
+        :description => "%DESCRIPTION%",
+        :type => %TYPE%,
+        :validation => %VALIDATION%,
+        :maxlength => %MAXLENGTH%
+

data/lib/mcollective/generators/templates/ddl.erb

@@ -0,0 +1,8 @@
+metadata :name => "<%= meta[:name] || "%FULLNANE%" -%>",
+         :description => "<%= meta[:description] || "%DESCRIPTION%" -%>",
+         :author => "<%= meta[:author] || "%AUTHOR%" -%>",
+         :license => "<%= meta[:license] || "%LICENSE%" -%>",
+         :version => "<%= meta[:version] || "%VERSION%" -%>",
+         :url => "<%= meta[:url] || "%URL%" -%>",
+         :timeout => <%= meta[:timeout] || "%TIMEOUT%" %>
+

data/lib/mcollective/generators/templates/plugin.erb

@@ -0,0 +1,7 @@
+module MCollective
+  module <%= @mod_name%>
+    class <%= @plugin_name.capitalize -%><<%= @pclass%>
+<%= @content%>
+    end
+  end
+end

data/lib/mcollective/log.rb

@@ -0,0 +1,118 @@
+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
+
+      # reopen log files
+      def reopen
+        if @configured
+          @logger.reopen
+        end
+      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"
+
+          logger_class = MCollective::Logger.const_get("#{logger_type.capitalize}_logger")
+
+          set_logger(logger_class.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
+        path, line, method = execution_stack[3].split(/:(\d+)/)
+        "%s:%s%s" % [File.basename(path), line, method]
+      end
+
+      # this method is here to facilitate testing and from
+      def execution_stack
+        caller
+      end
+    end
+  end
+end

data/lib/mcollective/logger.rb

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

data/lib/mcollective/logger/base.rb

@@ -0,0 +1,77 @@
+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
+
+      def start
+        raise "The logging class did not supply a start method"
+      end
+
+      def log(level, from, msg)
+        raise "The logging class did not supply a log method"
+      end
+
+      def reopen
+        # reopen may not make sense to all Loggers, but we expect it of the API
+      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
+    end
+  end
+end

data/lib/mcollective/logger/console_logger.rb

@@ -0,0 +1,61 @@
+module MCollective
+  module Logger
+    # Implements 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, normal_output=STDERR, last_resort_output=STDERR)
+        if @known_levels.index(level) >= @known_levels.index(@active_level)
+          time = Time.new.strftime("%Y/%m/%d %H:%M:%S")
+
+          normal_output.puts("%s %s: %s %s" % [colorize(level, level), time, from, msg])
+        end
+      rescue
+        # if this fails we probably cant show the user output at all,
+        # STDERR it as last resort
+        last_resort_output.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 => Util.color(:red),
+                  :fatal => Util.color(:red),
+                  :warn  => Util.color(:yellow),
+                  :info  => Util.color(:green),
+                  :reset => Util.color(:reset)}
+
+        if colorize
+          return colors[level] || ""
+        else
+          return ""
+        end
+      end
+
+      # Helper to return a string in specific color
+      def colorize(level, msg)
+        "%s%s%s" % [ color(level), msg, color(:reset) ]
+      end
+    end
+  end
+end

data/lib/mcollective/logger/file_logger.rb

@@ -0,0 +1,53 @@
+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
+
+      def reopen
+        level = @logger.level
+        @logger.close
+        start
+        @logger.level = level
+      end
+    end
+  end
+end