puppet 4.9.4 → 4.10.0

data/lib/puppet/pops/types/p_object_type.rb

@@ -211,12 +211,10 @@ class PObjectType < PMetaType
       # TODO: Assumes Ruby implementation for now
       if(callable_type.is_a?(PVariantType))
         callable_type.types.map do |ct|
-          Functions::Dispatch.new(ct, name, [],
-            ct.block_type.nil? ? nil : 'block', nil, nil, false)
+          Functions::Dispatch.new(ct, name, [], false, ct.block_type.nil? ? nil : 'block')
         end
       else
-        [Functions::Dispatch.new(callable_type, name, [],
-          callable_type.block_type.nil? ? nil : 'block', nil, nil, false)]
+        [Functions::Dispatch.new(callable_type, name, [], false, callable_type.block_type.nil? ? nil : 'block')]
       end
     end
 
@@ -436,7 +434,7 @@ class PObjectType < PMetaType
       # This method should accept a hash and assume that type assertion has been made already (it is made
       # by the dispatch added here).
       if impl_class.respond_to?(:from_asserted_hash)
-        dispatcher.add_dispatch(from_hash_type, :from_hash, ['hash'], nil, EMPTY_ARRAY, EMPTY_ARRAY, false)
+        dispatcher.add(Functions::Dispatch.new(from_hash_type, :from_hash, ['hash']))
         def from_hash(hash)
           self.class.impl_class.from_asserted_hash(hash)
         end
@@ -444,7 +442,7 @@ class PObjectType < PMetaType
 
       # Add the dispatch that uses the standard #from_asserted_args or #new method on the class. It's assumed that the
       # method performs no assertions.
-      dispatcher.add_dispatch(create_type, :create, param_names, nil, EMPTY_ARRAY, EMPTY_ARRAY, false)
+      dispatcher.add(Functions::Dispatch.new(create_type, :create, param_names))
       if impl_class.respond_to?(:from_asserted_args)
         def create(*args)
           self.class.impl_class.from_asserted_args(*args)

data/lib/puppet/pops/types/ruby_generator.rb

@@ -263,11 +263,11 @@ class RubyGenerator < TypeFormatter
       bld << "  end\n"
 
       bld << "\n  def eql?(o)\n"
-      bld << "    super.eql?(o) &&\n" unless obj.parent.nil?
+      bld << "    super &&\n" unless obj.parent.nil?
       bld << "    self.class.eql?(o.class) &&\n" if include_class
       eq_names.each { |eqn| bld << '    @' << eqn << '.eql?(o.' <<  eqn << ") &&\n" }
       bld.chomp!(" &&\n")
-      bld << "\n  end\n"
+      bld << "\n  end\n  alias == eql?\n"
     end
   end
 end

data/lib/puppet/pops/types/type_asserter.rb

@@ -13,7 +13,7 @@ module TypeAsserter
   #
   # @api public
   def self.assert_assignable(subject, expected_type, type_to_check, &block)
-    report_type_mismatch(subject, expected_type, type_to_check) unless expected_type.assignable?(type_to_check)
+    report_type_mismatch(subject, expected_type, type_to_check, 'is incorrect', &block) unless expected_type.assignable?(type_to_check)
     type_to_check
   end
 
@@ -35,11 +35,11 @@ module TypeAsserter
     value
   end
 
-  def self.report_type_mismatch(subject, expected_type, actual_type)
+  def self.report_type_mismatch(subject, expected_type, actual_type, what = 'has wrong type')
     subject = yield(subject) if block_given?
     subject = subject[0] % subject[1..-1] if subject.is_a?(Array)
     raise TypeAssertionError.new(
-      TypeMismatchDescriber.singleton.describe_mismatch("#{subject} has wrong type,", expected_type, actual_type), expected_type, actual_type)
+      TypeMismatchDescriber.singleton.describe_mismatch("#{subject} #{what},", expected_type, actual_type), expected_type, actual_type)
   end
   private_class_method :report_type_mismatch
 end

data/lib/puppet/pops/types/type_mismatch_describer.rb

@@ -293,6 +293,11 @@ module Types
       super(path)
       @expected = (expected.is_a?(Array) ? PVariantType.maybe_create(expected) : expected).normalize
       @actual = actual.normalize
+      @optional = false
+    end
+
+    def set_optional
+      @optional = true
     end
 
     def ==(o)
@@ -323,8 +328,17 @@ module Types
       e = expected
       a = actual
       multi = false
-      if e.is_a?(PVariantType)
+      if @optional
+        if e.is_a?(PVariantType)
+          e = [PUndefType::DEFAULT] + e.types
+        else
+          e = [PUndefType::DEFAULT, e]
+        end
+      elsif e.is_a?(PVariantType)
         e = e.types
+      end
+
+      if e.is_a?(Array)
         if report_detailed?(e, a)
           a = detailed_actual_to_s(e, a)
           e = e.map { |t| t.to_alias_expanded_s }
@@ -620,7 +634,7 @@ module Types
         if param_hash.include?(name)
           result << describe(value_type, TypeCalculator.singleton.infer_set(value), [ParameterPathElement.new(name)]) unless value_type.instance?(value)
         else
-          result << MissingParameter.new(nil, name) unless elem.key_type.assignable?(PUndefType::DEFAULT) unless missing_ok
+          result << MissingParameter.new(nil, name) unless missing_ok || elem.key_type.is_a?(POptionalType)
         end
       end
       result
@@ -764,7 +778,10 @@ module Types
     end
 
     def describe_POptionalType(expected, actual, path)
-      actual.is_a?(PUndefType) ? [] : describe(expected.optional_type, actual, path)
+      return EMPTY_ARRAY if actual.is_a?(PUndefType)
+      descriptions = describe(expected.optional_type, actual, path)
+      descriptions.each { |description| description.set_optional }
+      descriptions
     end
 
     def describe_PEnumType(expected, actual, path)
@@ -776,7 +793,7 @@ module Types
     end
 
     def describe_PTypeAliasType(expected, actual, path)
-      resolved_type = expected.resolved_type.normalize
+      resolved_type = expected.resolved_type
       describe(resolved_type, actual, path).map do |description|
         if description.is_a?(ExpectedActualMismatch) && description.expected.equal?(resolved_type)
           description.swap_expected(expected)
@@ -804,7 +821,7 @@ module Types
         expected_size = expected.size_type
         actual_size = actual.size_type || PCollectionType::DEFAULT_SIZE
         if expected_size.nil? || expected_size.assignable?(actual_size)
-          descriptions << TypeMismatch.new(path, expected, actual)
+          descriptions << TypeMismatch.new(path, expected, PArrayType.new(actual.element_type))
         else
           descriptions << SizeMismatch.new(path, expected_size, actual_size)
         end
@@ -834,7 +851,7 @@ module Types
         expected_size = expected.size_type
         actual_size = actual.size_type || PCollectionType::DEFAULT_SIZE
         if expected_size.nil? || expected_size.assignable?(actual_size)
-          descriptions << TypeMismatch.new(path, expected, actual)
+          descriptions << TypeMismatch.new(path, expected, PHashType.new(actual.key_type, actual.value_type))
         else
           descriptions << SizeMismatch.new(path, expected_size, actual_size)
         end
@@ -864,7 +881,7 @@ module Types
         actual_size = actual.size_type || PCollectionType::DEFAULT_SIZE
         expected_size = PIntegerType.new(elements.count { |e| !e.key_type.assignable?(PUndefType::DEFAULT) }, elements.size)
         if expected_size.assignable?(actual_size)
-          descriptions << TypeMismatch.new(path, expected, actual)
+          descriptions << TypeMismatch.new(path, expected, PHashType.new(actual.key_type, actual.value_type))
         else
           descriptions << SizeMismatch.new(path, expected_size, actual_size)
         end
@@ -990,6 +1007,7 @@ module Types
       if unresolved
         [UnresolvedTypeReference.new(path, unresolved)]
       else
+        expected = expected.normalize
         case expected
         when PVariantType
           describe_PVariantType(expected, actual, path)

data/lib/puppet/pops/types/types.rb

@@ -2522,7 +2522,7 @@ class PHashType < PCollectionType
       key_t = key_t.normalize(guard) unless key_t.nil?
       value_t = @value_type
       value_t = value_t.normalize(guard) unless value_t.nil?
-      @size_type.nil? && @key_type.equal?(key_t) && @value_type.equal?(value_t) ? self : PHashType.new(key_t, value_t, nil)
+      @size_type.nil? && @key_type.equal?(key_t) && @value_type.equal?(value_t) ? self : PHashType.new(key_t, value_t, @size_type)
     end
   end
 
@@ -2668,7 +2668,7 @@ class PVariantType < PAnyType
   # @return [PAnyType] the resulting type
   # @api public
   def self.maybe_create(types)
-    types = types.uniq
+    types = flatten_variants(types).uniq
     types.size == 1 ? types[0] : new(types)
   end
 
@@ -2713,24 +2713,15 @@ class PVariantType < PAnyType
 
       if types.size == 1
         types[0]
-      elsif types.any? { |t| t.is_a?(PUndefType) }
-        # Undef entry present. Use an OptionalType with a normalized Variant of all types that are not Undef
-        POptionalType.new(PVariantType.maybe_create(types.reject { |ot| ot.is_a?(PUndefType) }).normalize(guard)).normalize(guard)
+      elsif types.any? { |t| t.is_a?(PUndefType) || t.is_a?(POptionalType) }
+        # Undef entry present. Use an OptionalType with a normalized Variant without Undefs and Optional wrappers
+        POptionalType.new(PVariantType.maybe_create(types.reject { |t| t.is_a?(PUndefType) }.map { |t| t.is_a?(POptionalType) ? t.type : t })).normalize
       else
         # Merge all variants into this one
-        types = types.map do |t|
-          if t.is_a?(PVariantType)
-            modified = true
-            t.types
-          else
-            t
-          end
-        end
-        types.flatten! if modified
+        types = PVariantType.flatten_variants(types)
         size_before_merge = types.size
 
         types = swap_not_undefs(types)
-        types = swap_optionals(types)
         types = merge_enums(types)
         types = merge_patterns(types)
         types = merge_version_ranges(types)
@@ -2748,6 +2739,20 @@ class PVariantType < PAnyType
     end
   end
 
+  def self.flatten_variants(types)
+    modified = false
+    types = types.map do |t|
+      if t.is_a?(PVariantType)
+        modified = true
+        t.types
+      else
+        t
+      end
+    end
+    types.flatten! if modified
+    types
+  end
+
   def hash
     @types.hash
   end
@@ -2806,20 +2811,6 @@ class PVariantType < PAnyType
     end
   end
 
-  # @api private
-  def swap_optionals(array)
-    if array.size > 1
-      parts = array.partition {|t| t.is_a?(POptionalType) }
-      optionals = parts[0]
-      if optionals.size > 1
-        others = parts[1]
-        others <<  POptionalType.new(PVariantType.maybe_create(optionals.map { |optional| optional.type }).normalize)
-        array = others
-      end
-    end
-    array
-  end
-
   # @api private
   def swap_not_undefs(array)
     if array.size > 1

data/lib/puppet/provider/exec.rb

@@ -8,6 +8,7 @@ class Puppet::Provider::Exec < Puppet::Provider
     output = nil
     status = nil
     dir = nil
+    sensitive = resource.parameters[:command].sensitive
 
     checkexe(command)
 
@@ -23,7 +24,7 @@ class Puppet::Provider::Exec < Puppet::Provider
 
     dir ||= Dir.pwd
 
-    debug "Executing#{check ? " check": ""} '#{command}'"
+    debug "Executing#{check ? " check": ""} '#{sensitive ? '[redacted]' : command}'"
     begin
       # Do our chdir
       Dir.chdir(dir) do
@@ -59,7 +60,8 @@ class Puppet::Provider::Exec < Puppet::Provider
           output = Puppet::Util::Execution.execute(command, :failonfail => false, :combine => true,
                                   :uid => resource[:user], :gid => resource[:group],
                                   :override_locale => false,
-                                  :custom_environment => environment)
+                                  :custom_environment => environment,
+                                  :sensitive => sensitive)
         end
         # The shell returns 127 if the command is missing.
         if output.exitstatus == 127

data/lib/puppet/provider/nameservice.rb

@@ -52,14 +52,14 @@ class Puppet::Provider::NameService < Puppet::Provider
     # for both users and groups.
     def listbyname
       names = []
-      Etc.send("set#{section()}ent")
+      Puppet::Etc.send("set#{section()}ent")
       begin
-        while ent = Etc.send("get#{section()}ent")
+        while ent = Puppet::Etc.send("get#{section()}ent")
           names << ent.name
           yield ent.name if block_given?
         end
       ensure
-        Etc.send("end#{section()}ent")
+        Puppet::Etc.send("end#{section()}ent")
       end
 
       names
@@ -146,7 +146,7 @@ class Puppet::Provider::NameService < Puppet::Provider
       # other, more convenient enumerator for these, so we fake one with this
       # loop.  Thanks, Ruby, for your awesome abstractions. --daniel 2012-03-23
       highest = []
-      Etc.send(database) {|entry| highest << entry.send(method) }
+      Puppet::Etc.send(database) {|entry| highest << entry.send(method) }
       highest = highest.reject {|x| x > 65000 }.max
 
       @prevauto = highest || 1000
@@ -226,7 +226,7 @@ class Puppet::Provider::NameService < Puppet::Provider
     if @objectinfo.nil? or refresh == true
       @etcmethod ||= ("get" + self.class.section.to_s + "nam").intern
       begin
-        @objectinfo = Etc.send(@etcmethod, @resource[:name])
+        @objectinfo = Puppet::Etc.send(@etcmethod, @resource[:name])
       rescue ArgumentError
         @objectinfo = nil
       end
@@ -242,13 +242,13 @@ class Puppet::Provider::NameService < Puppet::Provider
     groups = []
 
     # Reset our group list
-    Etc.setgrent
+    Puppet::Etc.setgrent
 
     user = @resource[:name]
 
     # Now iterate across all of the groups, adding each one our
     # user is a member of
-    while group = Etc.getgrent
+    while group = Puppet::Etc.getgrent
       members = group.mem
 
       groups << group.name if members.include? user
@@ -256,7 +256,7 @@ class Puppet::Provider::NameService < Puppet::Provider
 
     # We have to close the file, so each listing is a separate
     # reading of the file.
-    Etc.endgrent
+    Puppet::Etc.endgrent
 
     groups.join(",")
   end

data/lib/puppet/provider/selmodule/semodule.rb

@@ -79,35 +79,39 @@ Puppet::Type.type(:selmodule).provide(:semodule) do
 
   def selmodversion_file
     magic = 0xF97CFF8F
+    v = nil
 
     filename = selmod_name_to_filename
-    mod = File.new(filename, "r")
+    # Open a file handle and parse the bytes until version is found
+    Puppet::FileSystem.open(filename, nil, 'rb') do |mod|
 
-    (hdr, ver, numsec) = mod.read(12).unpack('VVV')
+      (hdr, ver, numsec) = mod.read(12).unpack('VVV')
 
-    raise Puppet::Error, "Found #{hdr} instead of magic #{magic} in #{filename}" if hdr != magic
+      raise Puppet::Error, "Found #{hdr} instead of magic #{magic} in #{filename}" if hdr != magic
 
-    raise Puppet::Error, "Unknown policy file version #{ver} in #{filename}" if ver != 1
+      raise Puppet::Error, "Unknown policy file version #{ver} in #{filename}" if ver != 1
 
-    # Read through (and throw away) the file section offsets, and also
-    # the magic header for the first section.
+      # Read through (and throw away) the file section offsets, and also
+      # the magic header for the first section.
 
-    mod.read((numsec + 1) * 4)
+      mod.read((numsec + 1) * 4)
 
-    ## Section 1 should be "SE Linux Module"
+      ## Section 1 should be "SE Linux Module"
 
-    selmod_readnext(mod)
-    selmod_readnext(mod)
+      selmod_readnext(mod)
+      selmod_readnext(mod)
 
-    # Skip past the section headers
-    mod.read(14)
+      # Skip past the section headers
+      mod.read(14)
 
-    # Module name
-    selmod_readnext(mod)
+      # Module name
+      selmod_readnext(mod)
 
-    # At last!  the version
+      # At last!  the version
 
-    v = selmod_readnext(mod)
+      v = selmod_readnext(mod)
+
+    end
 
     self.debug "file version #{v}"
     v

data/lib/puppet/provider/service/src.rb

@@ -91,56 +91,56 @@ Puppet::Type.type(:service).provide :src, :parent => :base do
   end
 
   def restart
-      execute([command(:lssrc), "-Ss", @resource[:name]]).each_line do |line|
-        args = line.split(":")
-
-        next unless args[0] == @resource[:name]
-
-        # Subsystems with the -K flag can get refreshed (HUPed)
-        # While subsystems with -S (signals) must be stopped/started
-        method = args[11]
-        do_refresh = case method
-          when "-K" then :true
-          when "-S" then :false
-          else self.fail("Unknown service communication method #{method}")
-        end
+    execute([command(:lssrc), "-Ss", @resource[:name]]).each_line do |line|
+      args = line.split(":")
+
+      next unless args[0] == @resource[:name]
+
+      # Subsystems with the -K flag can get refreshed (HUPed)
+      # While subsystems with -S (signals) must be stopped/started
+      method = args[11]
+      do_refresh = case method
+        when "-K" then :true
+        when "-S" then :false
+        else self.fail("Unknown service communication method #{method}")
+      end
 
-        begin
-          if do_refresh == :true
-            execute([command(:refresh), "-s", @resource[:name]])
-          else
-            self.stop
-            self.start
-          end
-          return :true
-        rescue Puppet::ExecutionFailure => detail
-          raise Puppet::Error.new("Unable to restart service #{@resource[:name]}, error was: #{detail}", detail )
+      begin
+        if do_refresh == :true
+          execute([command(:refresh), "-s", @resource[:name]])
+        else
+          self.stop
+          self.start
         end
+        return :true
+      rescue Puppet::ExecutionFailure => detail
+        raise Puppet::Error.new("Unable to restart service #{@resource[:name]}, error was: #{detail}", detail )
       end
-      self.fail("No such service found")
+    end
+    self.fail("No such service found")
   rescue Puppet::ExecutionFailure => detail
-      raise Puppet::Error.new("Cannot get status of #{@resource[:name]}, error was: #{detail}", detail )
+    raise Puppet::Error.new("Cannot get status of #{@resource[:name]}, error was: #{detail}", detail )
   end
 
   def status
-      execute([command(:lssrc), "-s", @resource[:name]]).each_line do |line|
-        args = line.split
+    execute([command(:lssrc), "-s", @resource[:name]]).each_line do |line|
+      args = line.split
 
-        # This is the header line
-        next unless args[0] == @resource[:name]
+      # This is the header line
+      next unless args[0] == @resource[:name]
 
-        # PID is the 3rd field, but inoperative subsystems
-        # skip this so split doesn't work right
-        state = case args[-1]
-          when "active" then :running
-          when "inoperative" then :stopped
-        end
-        Puppet.debug("Service #{@resource[:name]} is #{args[-1]}")
-        return state
+      # PID is the 3rd field, but inoperative subsystems
+      # skip this so split doesn't work right
+      state = case args[-1]
+        when "active" then :running
+        when "inoperative" then :stopped
       end
-      self.fail("No such service found")
+      Puppet.debug("Service #{@resource[:name]} is #{args[-1]}")
+      return state
+    end
   rescue Puppet::ExecutionFailure => detail
-      raise Puppet::Error.new("Cannot get status of #{@resource[:name]}, error was: #{detail}", detail )
+    self.debug(detail.message)
+    return :stopped
   end
 
 end