mcollective-client 2.0.0 → 2.2.0

data/lib/mcollective/security/base.rb

@@ -74,26 +74,33 @@ module MCollective
 
           when "compound"
             filter[key].each do |compound|
-              result = []
-
-              compound.each do |expression|
-                case expression.keys.first
-                when "statement"
-                  result << Util.eval_compound_statement(expression).to_s
-                when "and"
-                  result << "&&"
-                when "or"
-                  result << "||"
-                when "("
-                  result << "("
-                when ")"
-                  result << ")"
-                when "not"
-                  result << "!"
+              result = false
+              truth_values = []
+
+              begin
+                compound.each do |expression|
+                  case expression.keys.first
+                    when "statement"
+                      truth_values << Matcher.eval_compound_statement(expression).to_s
+                    when "fstatement"
+                      truth_values << Matcher.eval_compound_fstatement(expression.values.first)
+                    when "and"
+                      truth_values << "&&"
+                    when "or"
+                      truth_values << "||"
+                    when "("
+                      truth_values << "("
+                    when ")"
+                      truth_values << ")"
+                    when "not"
+                      truth_values << "!"
+                  end
                 end
-              end
 
-              result = eval(result.join(" "))
+                result = eval(truth_values.join(" "))
+              rescue DDLValidationError
+                result = false
+              end
 
               if result
                 Log.debug("Passing based on class and fact composition")
@@ -161,24 +168,24 @@ module MCollective
         Log.debug("Encoded a message for request #{reqid}")
 
         {:senderid => @config.identity,
-          :requestid => reqid,
-          :senderagent => agent,
-          :msgtime => Time.now.utc.to_i,
-          :body => body}
+         :requestid => reqid,
+         :senderagent => agent,
+         :msgtime => Time.now.utc.to_i,
+         :body => body}
       end
 
       def create_request(reqid, filter, msg, initiated_by, target_agent, target_collective, ttl=60)
         Log.debug("Encoding a request for agent '#{target_agent}' in collective #{target_collective} with request id #{reqid}")
 
         {:body => msg,
-          :senderid => @config.identity,
-          :requestid => reqid,
-          :filter => filter,
-          :collective => target_collective,
-          :agent => target_agent,
-          :callerid => callerid,
-          :ttl => ttl,
-          :msgtime => Time.now.utc.to_i}
+         :senderid => @config.identity,
+         :requestid => reqid,
+         :filter => filter,
+         :collective => target_collective,
+         :agent => target_agent,
+         :callerid => callerid,
+         :ttl => ttl,
+         :msgtime => Time.now.utc.to_i}
       end
 
       # Give a MC::Message instance and a message id this will figure out if you the incoming
@@ -215,22 +222,22 @@ module MCollective
 
       # Security providers should provide this, see MCollective::Security::Psk
       def validrequest?(req)
-        Log.error("validrequest? is not implimented in #{self.class}")
+        Log.error("validrequest? is not implemented in #{self.class}")
       end
 
       # Security providers should provide this, see MCollective::Security::Psk
       def encoderequest(sender, msg, filter={})
-        Log.error("encoderequest is not implimented in #{self.class}")
+        Log.error("encoderequest is not implemented in #{self.class}")
       end
 
       # Security providers should provide this, see MCollective::Security::Psk
       def encodereply(sender, msg, requestcallerid=nil)
-        Log.error("encodereply is not implimented in #{self.class}")
+        Log.error("encodereply is not implemented in #{self.class}")
       end
 
       # Security providers should provide this, see MCollective::Security::Psk
       def decodemsg(msg)
-        Log.error("decodemsg is not implimented in #{self.class}")
+        Log.error("decodemsg is not implemented in #{self.class}")
       end
     end
   end

data/lib/mcollective/shell.rb

@@ -7,7 +7,7 @@ module MCollective
   #   s.runcommand
   #   puts s.stdout
   #   puts s.stderr
-  #   puts s.status.exitcode
+  #   puts s.status.exitstatus
   #
   # Options hash can have:
   #

data/lib/mcollective/ssl.rb

@@ -204,12 +204,46 @@ module MCollective
       Digest::MD5.hexdigest(string)
     end
 
+    # Creates a RFC 4122 version 5 UUID. If string is supplied it will produce repeatable
+    # UUIDs for that string else a random 128bit string will be used from OpenSSL::BN
+    #
+    # Code used with permission from:
+    #    https://github.com/kwilczynski/puppet-functions/blob/master/lib/puppet/parser/functions/uuid.rb
+    #
+    def self.uuid(string=nil)
+      string ||= OpenSSL::Random.random_bytes(16).unpack('H*').shift
+
+      uuid_name_space_dns = "\x6b\xa7\xb8\x10\x9d\xad\x11\xd1\x80\xb4\x00\xc0\x4f\xd4\x30\xc8"
+
+      sha1 = Digest::SHA1.new
+      sha1.update(uuid_name_space_dns)
+      sha1.update(string)
+
+      # first 16 bytes..
+      bytes = sha1.digest[0, 16].bytes.to_a
+
+      # version 5 adjustments
+      bytes[6] &= 0x0f
+      bytes[6] |= 0x50
+
+      # variant is DCE 1.1
+      bytes[8] &= 0x3f
+      bytes[8] |= 0x80
+
+      bytes = [4, 2, 2, 2, 6].collect do |i|
+        bytes.slice!(0, i).pack('C*').unpack('H*')
+      end
+
+      bytes.join('-')
+    end
+
     # Reads either a :public or :private key from disk, uses an
     # optional passphrase to read the private key
     def read_key(type, key=nil, passphrase=nil)
       return key if key.nil?
 
       raise "Could not find key #{key}" unless File.exist?(key)
+      raise "#{type} key file '#{key}' is empty" if File.zero?(key)
 
       if type == :public
         begin

data/lib/mcollective/util.rb

@@ -129,10 +129,10 @@ module MCollective
     # Creates an empty filter
     def self.empty_filter
       {"fact"     => [],
-        "cf_class" => [],
-        "agent"    => [],
-        "identity" => [],
-        "compound" => []}
+       "cf_class" => [],
+       "agent"    => [],
+       "identity" => [],
+       "compound" => []}
     end
 
     # Picks a config file defaults to ~/.mcollective
@@ -156,12 +156,14 @@ module MCollective
 
     # Creates a standard options hash
     def self.default_options
-      {:verbose     => false,
-        :disctimeout => 2,
-        :timeout     => 5,
-        :config      => config_file_for_user,
-        :collective  => nil,
-        :filter      => empty_filter}
+      {:verbose           => false,
+       :disctimeout       => nil,
+       :timeout           => 5,
+       :config            => config_file_for_user,
+       :collective        => nil,
+       :discovery_method  => nil,
+       :discovery_options => Config.instance.default_discovery_options,
+       :filter            => empty_filter}
     end
 
     def self.make_subscriptions(agent, type, collective=nil)
@@ -247,28 +249,197 @@ module MCollective
       !!(RbConfig::CONFIG['host_os'] =~ /mswin|win32|dos|mingw|cygwin/i)
     end
 
-    def self.eval_compound_statement(expression)
-      if expression.values.first =~ /^\//
-        return Util.has_cf_class?(expression.values.first)
-      elsif expression.values.first =~ />=|<=|=|<|>/
-        optype = expression.values.first.match(/>=|<=|=|<|>/)
-        name, value = expression.values.first.split(optype[0])
-        unless value.split("")[0] == "/"
-          optype[0] == "=" ? optype = "==" : optype = optype[0]
-        else
-          optype = "=~"
-        end
+    # Return color codes, if the config color= option is false
+    # just return a empty string
+    def self.color(code)
+      colorize = Config.instance.color
 
-        return Util.has_fact?(name,value, optype).to_s
+      colors = {:red => "",
+                :green => "",
+                :yellow => "",
+                :cyan => "",
+                :bold => "",
+                :reset => ""}
+
+      if colorize
+        return colors[code] || ""
       else
-        return Util.has_cf_class?(expression.values.first)
+        return ""
       end
     end
 
+    # Helper to return a string in specific color
+    def self.colorize(code, msg)
+      "%s%s%s" % [ color(code), msg, color(:reset) ]
+    end
+
     # Returns the current ruby version as per RUBY_VERSION, mostly
     # doing this here to aid testing
     def self.ruby_version
       RUBY_VERSION
     end
+
+    def self.mcollective_version
+      MCollective::VERSION
+    end
+
+    # Returns an aligned_string of text relative to the size of the terminal
+    # window. If a line in the string exceeds the width of the terminal window
+    # the line will be chopped off at the whitespace chacter closest to the
+    # end of the line and prepended to the next line, keeping all indentation.
+    #
+    # The terminal size is detected by default, but custom line widths can
+    # passed. All strings will also be left aligned with 5 whitespace characters
+    # by default.
+    def self.align_text(text, console_cols = nil, preamble = 5)
+      unless console_cols
+        console_cols = terminal_dimensions[0]
+
+        # if unknown size we default to the typical unix default
+        console_cols = 80 if console_cols == 0
+      end
+
+      console_cols -= preamble
+
+      # Return unaligned text if console window is too small
+      return text if console_cols <= 0
+
+      # If console is 0 this implies unknown so we assume the common
+      # minimal unix configuration of 80 characters
+      console_cols = 80 if console_cols <= 0
+
+      text = text.split("\n")
+      piece = ''
+      whitespace = 0
+
+      text.each_with_index do |line, i|
+        whitespace = 0
+
+        while whitespace < line.length && line[whitespace].chr == ' '
+          whitespace += 1
+        end
+
+        # If the current line is empty, indent it so that a snippet
+        # from the previous line is aligned correctly.
+        if line == ""
+          line = (" " * whitespace)
+        end
+
+        # If text was snipped from the previous line, prepend it to the
+        # current line after any current indentation.
+        if piece != ''
+          # Reset whitespaces to 0 if there are more whitespaces than there are
+          # console columns
+          whitespace = 0 if whitespace >= console_cols
+
+          # If the current line is empty and being prepended to, create a new
+          # empty line in the text so that formatting is preserved.
+          if text[i + 1] && line == (" " * whitespace)
+            text.insert(i + 1, "")
+          end
+
+          # Add the snipped text to the current line
+          line.insert(whitespace, "#{piece} ")
+        end
+
+        piece = ''
+
+        # Compare the line length to the allowed line length.
+        # If it exceeds it, snip the offending text from the line
+        # and store it so that it can be prepended to the next line.
+        if line.length > (console_cols + preamble)
+          reverse = console_cols
+
+          while line[reverse].chr != ' '
+            reverse -= 1
+          end
+
+          piece = line.slice!(reverse, (line.length - 1)).lstrip
+        end
+
+        # If a snippet exists when all the columns in the text have been
+        # updated, create a new line and append the snippet to it, using
+        # the same left alignment as the last line in the text.
+        if piece != '' && text[i+1].nil?
+          text[i+1] = "#{' ' * (whitespace)}#{piece}"
+          piece = ''
+        end
+
+        # Add the preamble to the line and add it to the text
+        line = ((' ' * preamble) + line)
+        text[i] = line
+      end
+
+      text.join("\n")
+    end
+
+    # Figures out the columns and lines of the current tty
+    #
+    # Returns [0, 0] if it can't figure it out or if you're
+    # not running on a tty
+    def self.terminal_dimensions(stdout = STDOUT, environment = ENV)
+      return [0, 0] unless stdout.tty?
+
+      return [80, 40] if Util.windows?
+
+      if environment["COLUMNS"] && environment["LINES"]
+        return [environment["COLUMNS"].to_i, environment["LINES"].to_i]
+
+      elsif environment["TERM"] && command_in_path?("tput")
+        return [`tput cols`.to_i, `tput lines`.to_i]
+
+      elsif command_in_path?('stty')
+        return `stty size`.scan(/\d+/).map {|s| s.to_i }
+      else
+        return [0, 0]
+      end
+    rescue
+      [0, 0]
+    end
+
+    # Checks in PATH returns true if the command is found
+    def self.command_in_path?(command)
+      found = ENV["PATH"].split(File::PATH_SEPARATOR).map do |p|
+        File.exist?(File.join(p, command))
+      end
+
+      found.include?(true)
+    end
+
+    # compare two software versions as commonly found in
+    # package versions.
+    #
+    # returns 0 if a == b
+    # returns -1 if a < b
+    # returns 1 if a > b
+    #
+    # Code originally from Puppet but refactored to a more
+    # ruby style that fits in better with this code base
+    def self.versioncmp(version_a, version_b)
+      vre = /[-.]|\d+|[^-.\d]+/
+      ax = version_a.scan(vre)
+      bx = version_b.scan(vre)
+
+      until ax.empty? || bx.empty?
+        a = ax.shift
+        b = bx.shift
+
+        next      if a == b
+        next      if a == '-' && b == '-'
+        return -1 if a == '-'
+        return 1  if b == '-'
+        next      if a == '.' && b == '.'
+        return -1 if a == '.'
+        return 1  if b == '.'
+
+        if a =~ /^[^0]\d+$/ && b =~ /^[^0]\d+$/
+          return Integer(a) <=> Integer(b)
+        else
+          return a.upcase <=> b.upcase
+        end
+      end
+
+      version_a <=> version_b
+    end
   end
 end

data/lib/mcollective/validator.rb

@@ -0,0 +1,80 @@
+module MCollective
+  module Validator
+    @last_load = nil
+
+    # Loads the validator plugins. Validators will only be loaded every 5 minutes
+    def self.load_validators
+      if load_validators?
+        @last_load = Time.now.to_i
+        PluginManager.find_and_load("validator")
+      end
+    end
+
+    # Returns and instance of the Plugin class from which objects can be created.
+    # Valid plugin names are
+    #   :valplugin
+    #   "valplugin"
+    #   "ValpluginValidator"
+    def self.[](klass)
+      if klass.is_a?(Symbol)
+        klass = validator_class(klass)
+      elsif !(klass.match(/.*Validator$/))
+        klass = validator_class(klass)
+      end
+
+      const_get(klass)
+    end
+
+    # Allows validation plugins to be called like module methods : Validator.validate()
+    def self.method_missing(method, *args, &block)
+      if has_validator?(method)
+        validator = Validator[method].validate(*args)
+      else
+        raise ValidatorError, "Unknown validator: '#{method}'."
+      end
+    end
+
+    def self.has_validator?(validator)
+      const_defined?(validator_class(validator))
+    end
+
+    def self.validator_class(validator)
+      "#{validator.to_s.capitalize}Validator"
+    end
+
+    def self.load_validators?
+      return true if @last_load.nil?
+
+      (@last_load - Time.now.to_i) > 300
+    end
+
+    # Generic validate method that will call the correct validator
+    # plugin based on the type of the validation parameter
+    def self.validate(validator, validation)
+      Validator.load_validators
+
+      begin
+        if [:integer, :boolean, :float, :number, :string].include?(validation)
+          Validator.typecheck(validator, validation)
+
+        else
+          case validation
+            when Regexp,String
+              Validator.regex(validator, validation)
+
+            when Symbol
+              Validator.send(validation, validator)
+
+            when Array
+              Validator.array(validator, validation)
+
+            when Class
+              Validator.typecheck(validator, validation)
+          end
+        end
+      rescue => e
+        raise ValidatorError, e.to_s
+      end
+    end
+  end
+end