mcollective-client 2.7.0 → 2.8.0

data/lib/mcollective/data/fstat_data.ddl

@@ -0,0 +1,89 @@
+metadata    :name        => "File Stat",
+            :description => "Retrieve file stat data for a given file",
+            :author      => "R.I.Pienaar <rip@devco.net>",
+            :license     => "ASL 2.0",
+            :version     => "1.0",
+            :url         => "http://marionette-collective.org/",
+            :timeout     => 1
+
+dataquery :description => "File stat information" do
+    input :query,
+          :prompt => "File Name",
+          :description => "Valid File Name",
+          :type => :string,
+          :validation => /.+/,
+          :maxlength => 120
+
+    output :name,
+           :description => "File name",
+           :display_as => "Name"
+
+    output :output,
+           :description => "Human readable information about the file",
+           :display_as => "Status"
+
+    output :present,
+           :description => "Indicates if the file exist using 0 or 1",
+           :display_as => "Present"
+
+    output :size,
+           :description => "File size",
+           :display_as => "Size"
+
+    output :mode,
+           :description => "File mode",
+           :display_as => "Mode"
+
+    output :md5,
+           :description => "File MD5 digest",
+           :display_as => "MD5"
+
+    output :mtime,
+           :description => "File modification time",
+           :display_as => "Modification time"
+
+    output :ctime,
+           :description => "File change time",
+           :display_as => "Change time"
+
+    output :atime,
+           :description => "File access time",
+           :display_as => "Access time"
+
+    output :mtime_seconds,
+           :description => "File modification time in seconds",
+           :display_as => "Modification time"
+
+    output :ctime_seconds,
+           :description => "File change time in seconds",
+           :display_as => "Change time"
+
+    output :atime_seconds,
+           :description => "File access time in seconds",
+           :display_as => "Access time"
+
+    output :mtime_age,
+           :description => "File modification age in seconds",
+           :display_as => "Modification age"
+
+    output :ctime_age,
+           :description => "File change age in seconds",
+           :display_as => "Change age"
+
+    output :atime_age,
+           :description => "File access age in seconds",
+           :display_as => "Access age"
+
+    output :uid,
+           :description => "File owner",
+           :display_as => "Owner"
+
+    output :gid,
+           :description => "File group",
+           :display_as => "Group"
+
+    output :type,
+           :description => "File type",
+           :display_as => "Type"
+end
+

data/lib/mcollective/data/fstat_data.rb

@@ -0,0 +1,56 @@
+module MCollective
+  module Data
+    class Fstat_data<Base
+      query do |file|
+        result[:name] = file
+        result[:output] = "not present"
+        result[:type] = "unknown"
+        result[:mode] = "0000"
+        result[:present] = 0
+        result[:size] = 0
+        result[:mtime] = 0
+        result[:ctime] = 0
+        result[:atime] = 0
+        result[:mtime_seconds] = 0
+        result[:ctime_seconds] = 0
+        result[:atime_seconds] = 0
+        result[:md5] = 0
+        result[:uid] = 0
+        result[:gid] = 0
+
+
+        if File.exists?(file)
+          result[:output] = "present"
+          result[:present] = 1
+
+          if File.symlink?(file)
+            stat = File.lstat(file)
+          else
+            stat = File.stat(file)
+          end
+
+          [:size, :uid, :gid].each do |item|
+            result[item] = stat.send(item)
+          end
+
+          [:mtime, :ctime, :atime].each do |item|
+            result[item] = stat.send(item).strftime("%F %T")
+            result["#{item}_seconds".to_sym] = stat.send(item).to_i
+            result["#{item}_age".to_sym] = Time.now.to_i - stat.send(item).to_i
+          end
+
+          result[:mode] = "%o" % [stat.mode]
+          result[:md5] = Digest::MD5.hexdigest(File.read(file)) if stat.file?
+
+          result[:type] = "directory" if stat.directory?
+          result[:type] = "file" if stat.file?
+          result[:type] = "symlink" if stat.symlink?
+          result[:type] = "socket" if stat.socket?
+          result[:type] = "chardev" if stat.chardev?
+          result[:type] = "blockdev" if stat.blockdev?
+        end
+      end
+    end
+  end
+end
+

data/lib/mcollective/data.rb

@@ -1,7 +1,7 @@
 module MCollective
   module Data
-    autoload :Base, "mcollective/data/base"
-    autoload :Result, "mcollective/data/result"
+    require "mcollective/data/base"
+    require "mcollective/data/result"
 
     def self.load_data_sources
       PluginManager.find_and_load("data")

data/lib/mcollective/ddl.rb

@@ -48,10 +48,10 @@ module MCollective
   # content though so you add, do not remove.  See the AgentDDL class for an example
   # where agents want a :required argument to be always set.
   module DDL
-    autoload :Base, "mcollective/ddl/base"
-    autoload :AgentDDL, "mcollective/ddl/agentddl"
-    autoload :DataDDL, "mcollective/ddl/dataddl"
-    autoload :DiscoveryDDL, "mcollective/ddl/discoveryddl"
+    require "mcollective/ddl/base"
+    require "mcollective/ddl/agentddl"
+    require "mcollective/ddl/dataddl"
+    require "mcollective/ddl/discoveryddl"
 
     # There used to be only one big nasty DDL class with a bunch of mashed
     # together behaviors.  It's been around for ages and we would rather not

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         => "http://marionette-collective.org/",
+            :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         => "http://marionette-collective.org/",
+            :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         => "http://marionette-collective.org/",
+            :timeout     => 0
+
+discovery do
+    capabilities :identity
+end

data/lib/mcollective/discovery/stdin.rb

@@ -0,0 +1,66 @@
+# 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
+
+        if type == 'json'
+          hosts = MCollective::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/facts/yaml_facts.rb

@@ -0,0 +1,61 @@
+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)
+              facts.merge!(YAML.load(File.read(file)))
+            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/facts.rb

@@ -17,7 +17,7 @@ module MCollective
   #
   # method that should return a hash of facts.
   module Facts
-    autoload :Base, "mcollective/facts/base"
+    require "mcollective/facts/base"
 
     @@config = nil
 

data/lib/mcollective/generators.rb

@@ -1,7 +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"
+    require "mcollective/generators/base.rb"
+    require "mcollective/generators/data_generator.rb"
+    require "mcollective/generators/agent_generator.rb"
   end
 end

data/lib/mcollective/logger.rb

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

data/lib/mcollective/matcher/scanner.rb

@@ -152,7 +152,7 @@ module MCollective
         else
           if func
             if current_token_value.match(/^.+?\((\s*(')[^']*(')\s*(,\s*(')[^']*('))*)?\)(\.[a-zA-Z0-9_]+)?((!=|<=|>=|=|>|<).+)?$/) ||
-              current_token_value.match(/^.+?\((\s*(")[^"]*(")\s*(,\s*(")[^"]*("))*)?\)(\.[a-zA-Z0-9_]+)?((!=|<=|>=|=|>|<).+)?$/)
+               current_token_value.match(/^.+?\((\s*(")[^"]*(")\s*(,\s*(")[^"]*("))*)?\)(\.[a-zA-Z0-9_]+)?((!=|<=|>=|=|>|<).+)?$/)
               return "fstatement", current_token_value
             else
               return "bad_token", [@token_index - current_token_value.size + 1, @token_index]

data/lib/mcollective/matcher.rb

@@ -10,8 +10,8 @@ module MCollective
   # char = A-Z | a-z | < | > | => | =< | _ | - |* | / { A-Z | a-z | < | > | => | =< | _ | - | * | / | }
   # int = 0|1|2|3|4|5|6|7|8|9{|0|1|2|3|4|5|6|7|8|9|0}
   module Matcher
-    autoload :Parser, "mcollective/matcher/parser"
-    autoload :Scanner, "mcollective/matcher/scanner"
+    require "mcollective/matcher/parser"
+    require "mcollective/matcher/scanner"
 
     # Helper creates a hash from a function call string
     def self.create_function_hash(function_call)