mcollective-client 2.0.0 → 2.2.0

data/lib/mcollective/ddl/discoveryddl.rb

@@ -0,0 +1,52 @@
+module MCollective
+  module DDL
+    # DDL for discovery plugins, a full example can be seen below
+    #
+    # metadata    :name        => "mc",
+    #             :description => "MCollective Broadcast based discovery",
+    #             :author      => "R.I.Pienaar <rip@devco.net>",
+    #             :license     => "ASL 2.0",
+    #             :version     => "0.1",
+    #             :url         => "http://marionette-collective.org/",
+    #             :timeout     => 2
+    #
+    # discovery do
+    #     capabilities [:classes, :facts, :identity, :agents, :compound]
+    # end
+    class DiscoveryDDL<Base
+      def discovery_interface
+        @entities[:discovery]
+      end
+
+      # records valid capabilities for discovery plugins
+      def capabilities(*caps)
+        caps = [caps].flatten
+
+        raise "Discovery plugin capabilities can't be empty" if caps.empty?
+
+        caps.each do |cap|
+          if [:classes, :facts, :identity, :agents, :compound].include?(cap)
+            @entities[:discovery][:capabilities] << cap
+          else
+            raise "%s is not a valid capability, valid capabilities are :classes, :facts, :identity, :agents and :compound" % cap
+          end
+        end
+      end
+
+      # Creates the definition for new discovery plugins
+      #
+      #    discovery do
+      #       capabilities [:classes, :facts, :identity, :agents, :compound]
+      #    end
+      def discovery(&block)
+        raise "Discovery plugins can only have one definition" if @entities[:discovery]
+
+        @entities[:discovery] = {:capabilities => []}
+
+        @current_entity = :discovery
+        block.call if block_given?
+        @current_entity = nil
+      end
+    end
+  end
+end

data/lib/mcollective/ddl/validatorddl.rb

@@ -0,0 +1,6 @@
+module MCollective
+  module DDL
+    class ValidatorDDL<Base
+    end
+  end
+end

data/lib/mcollective/discovery.rb

@@ -0,0 +1,143 @@
+module MCollective
+  class Discovery
+    def initialize(client)
+      @known_methods = find_known_methods
+      @default_method = Config.instance.default_discovery_method
+      @client = client
+    end
+
+    def find_known_methods
+      PluginManager.find("discovery")
+    end
+
+    def has_method?(method)
+      @known_methods.include?(method)
+    end
+
+    def force_direct_mode?
+      discovery_method != "mc"
+    end
+
+    def discovery_method
+      method = "mc"
+
+      if @client.options[:discovery_method]
+        method = @client.options[:discovery_method]
+      else
+        method = @default_method
+      end
+
+      raise "Unknown discovery method %s" % method unless has_method?(method)
+
+      unless method == "mc"
+        raise "Custom discovery methods require direct addressing mode" unless Config.instance.direct_addressing
+      end
+
+      return method
+    end
+
+    def discovery_class
+      method = discovery_method.capitalize
+
+      PluginManager.loadclass("MCollective::Discovery::#{method}") unless self.class.const_defined?(method)
+
+      self.class.const_get(method)
+    end
+
+    def ddl
+      @ddl ||= DDL.new(discovery_method, :discovery)
+
+      # if the discovery method got changed we might have an old DDL cached
+      # this will detect that and reread the correct DDL from disk
+      unless @ddl.meta[:name] == discovery_method
+        @ddl = DDL.new(discovery_method, :discovery)
+      end
+
+      return @ddl
+    end
+
+    # Agent filters are always present no matter what, so we cant raise an error if the capabilities
+    # suggest the discovery method cant do agents we just have to rely on the discovery plugin to not
+    # do stupid things in the presense of a agent filter
+    def check_capabilities(filter)
+      capabilities = ddl.discovery_interface[:capabilities]
+
+      unless capabilities.include?(:classes)
+        raise "Cannot use class filters while using the '%s' discovery method" % discovery_method unless filter["cf_class"].empty?
+      end
+
+      unless capabilities.include?(:facts)
+        raise "Cannot use fact filters while using the '%s' discovery method" % discovery_method unless filter["fact"].empty?
+      end
+
+      unless capabilities.include?(:identity)
+        raise "Cannot use identity filters while using the '%s' discovery method" % discovery_method unless filter["identity"].empty?
+      end
+
+      unless capabilities.include?(:compound)
+        raise "Cannot use compound filters while using the '%s' discovery method" % discovery_method unless filter["compound"].empty?
+      end
+    end
+
+    # checks if compound filters are used and then forces the 'mc' discovery plugin
+    def force_discovery_method_by_filter(filter)
+      unless discovery_method == "mc"
+        unless filter["compound"].empty?
+          Log.info "Switching to mc discovery method because compound filters are used"
+          @client.options[:discovery_method] = "mc"
+
+          return true
+        end
+      end
+
+      return false
+    end
+
+    # if a compound filter is specified and it has any function
+    # then we read the DDL for each of those plugins and sum up
+    # the timeout declared in the DDL
+    def timeout_for_compound_filter(compound_filter)
+      return 0 if compound_filter.nil? || compound_filter.empty?
+
+      timeout = 0
+
+      compound_filter.each do |filter|
+        filter.each do |statement|
+          if statement["fstatement"]
+            pluginname = Data.pluginname(statement["fstatement"]["name"])
+            ddl = DDL.new(pluginname, :data)
+            timeout += ddl.meta[:timeout]
+          end
+        end
+      end
+
+      timeout
+    end
+
+    def discovery_timeout(timeout, filter)
+      timeout = ddl.meta[:timeout] unless timeout
+
+      unless (filter["compound"] && filter["compound"].empty?)
+        timeout + timeout_for_compound_filter(filter["compound"])
+      else
+        timeout
+      end
+    end
+
+    def discover(filter, timeout, limit)
+      raise "Limit has to be an integer" unless limit.is_a?(Fixnum)
+
+      force_discovery_method_by_filter(filter)
+
+      check_capabilities(filter)
+
+      discovered = discovery_class.discover(filter, discovery_timeout(timeout, filter), limit, @client)
+
+      if limit > 0
+        return discovered[0,limit]
+      else
+        return discovered
+      end
+    end
+  end
+end

data/lib/mcollective/generators.rb

@@ -0,0 +1,7 @@
+module MCollective
+  module Generators
+    autoload :Base, "mcollective/generators/base.rb"
+    autoload :DataGenerator, "mcollective/generators/data_generator.rb"
+    autoload :AgentGenerator, "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

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/logger/console_logger.rb

@@ -1,6 +1,6 @@
 module MCollective
   module Logger
-    # Impliments a syslog based logger using the standard ruby syslog class
+    # Implements a syslog based logger using the standard ruby syslog class
     class Console_logger<Base
       def start
         set_level(:info)
@@ -15,22 +15,22 @@ module MCollective
 
       def valid_levels
         {:info  => :info,
-          :warn  => :warning,
-          :debug => :debug,
-          :fatal => :crit,
-          :error => :err}
+         :warn  => :warning,
+         :debug => :debug,
+         :fatal => :crit,
+         :error => :err}
       end
 
-      def log(level, from, msg)
+      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")
-          lvltxt = colorize(level, level)
-          STDERR.puts("#{lvltxt} #{time}: #{from} #{msg}")
+
+          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
-        STDERR.puts("#{level}: #{msg}")
+        last_resort_output.puts("#{level}: #{msg}")
       end
 
       # Set some colors for various logging levels, will honor the
@@ -39,11 +39,11 @@ module MCollective
       def color(level)
         colorize = Config.instance.color
 
-        colors = {:error => "",
-          :fatal => "",
-          :warn => "",
-          :info => "",
-          :reset => ""}
+        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] || ""
@@ -54,7 +54,7 @@ module MCollective
 
       # Helper to return a string in specific color
       def colorize(level, msg)
-        "#{self.color(level)}#{msg}#{self.color(:reset)}"
+        "%s%s%s" % [ color(level), msg, color(:reset) ]
       end
     end
   end