puppet 3.5.0.rc1-x86-mingw32 → 3.5.0.rc2-x86-mingw32

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 68774f3730734ab16e94cda888db6e533562eed3
+  data.tar.gz: 3af085989e7b05303af4886ecd9b6cf9dcca5586
+SHA512:
+  metadata.gz: 0c48444d57e8347867ec3152abf91fd5e0db80d7715eea9c99f7958447ee565b6b5cea5dcf88e47d7649df1317518931be68347910f231432a795ceeee6ade9c
+  data.tar.gz: f0f08f854946f7db54edfb80e2d4a2a7602ca17c6214d5ddf89e15bd89f6d9efefccb0504714f49e878b384849b9baf1b71a25decb3ed762d43b2715239f81f5

data/lib/puppet/defaults.rb

@@ -870,9 +870,10 @@ EOT
     },
     :manifest => {
       :default    => "$manifestdir/site.pp",
-      :type       => :file,
+      :type       => :file_or_directory,
       :desc       => "The entry-point manifest file for puppet master or a directory of manifests
-        to be evaluated in alphabetical order.",
+        to be evaluated in alphabetical order. Puppet manages this path as a directory
+        if it exists or if the path ends with a / or \\.",
     },
     :code => {
       :default    => "",

data/lib/puppet/indirector/catalog/compiler.rb

@@ -32,7 +32,13 @@ class Puppet::Resource::Catalog::Compiler < Puppet::Indirector::Code
       end
 
       facts.add_timestamp
-      Puppet::Node::Facts.indirection.save(facts)
+
+      options = {
+        :environment => request.environment,
+        :transaction_uuid => request.options[:transaction_uuid],
+      }
+
+      Puppet::Node::Facts.indirection.save(facts, nil, options)
     end
   end
 

data/lib/puppet/parser/scope.rb

@@ -538,6 +538,9 @@ class Puppet::Parser::Scope
   def to_hash_future(recursive)
     if recursive and has_enclosing_scope?
       target = enclosing_scope.to_hash_future(recursive)
+      if !(inherited = inherited_scope).nil?
+        target.merge!(inherited.to_hash_future(recursive))
+      end
     else
       target = Hash.new
     end

data/lib/puppet/pops/evaluator/access_operator.rb

@@ -73,7 +73,7 @@ class Puppet::Pops::Evaluator::AccessOperator
   def access_PRegexpType(o, scope, keys)
     keys.flatten!
     unless keys.size == 1
-      blamed = keys.size == 0 ? @semantic : @semantic.keys[2]
+      blamed = keys.size == 0 ? @semantic : @semantic.keys[1]
       fail(Puppet::Pops::Issues::BAD_TYPE_SLICE_ARITY, blamed, :base_type => o, :min=>1, :actual => keys.size)
     end
     assert_keys(keys, o, 1, 1, String, Regexp)
@@ -214,7 +214,7 @@ class Puppet::Pops::Evaluator::AccessOperator
   def assert_keys(keys, o, min, max, *allowed_classes)
     size = keys.size
     unless size.between?(min, max || INFINITY)
-      fail(Puppet::Pops::Issues::BAD_TYPE_SLICE_ARITY, blamed, :base_type => o, :min=>1, :max => max, :actual => keys.size)
+      fail(Puppet::Pops::Issues::BAD_TYPE_SLICE_ARITY, @semantic, :base_type => o, :min=>1, :max => max, :actual => keys.size)
     end
     keys.each_with_index do |k, i|
       unless allowed_classes.any? {|clazz| k.is_a?(clazz) }
@@ -438,10 +438,12 @@ class Puppet::Pops::Evaluator::AccessOperator
   #   Resource[File, 'foo']['bar'] # => Value of the 'bar' parameter in the File['foo'] resource
   #
   def access_PResourceType(o, scope, keys)
+    blamed = keys.size == 0 ? @semantic : @semantic.keys[0]
     keys.flatten!
     if keys.size == 0
-      fail(Puppet::Pops::Issues::BAD_TYPE_SLICE_ARITY, o,
-        :base_type => Puppet::Pops::Types::TypeCalculator.new().string(o), :min => 1, :actual => 0)
+      max = o.type_name.nil? ? 2 : 1
+      fail(Puppet::Pops::Issues::BAD_TYPE_SLICE_ARITY, blamed,
+        :base_type => Puppet::Pops::Types::TypeCalculator.new().string(o), :min => 1, :max => max, :actual => 0)
     end
     if !o.title.nil?
       # lookup resource and return one or more parameter values
@@ -500,10 +502,12 @@ class Puppet::Pops::Evaluator::AccessOperator
   end
 
   def access_PHostClassType(o, scope, keys)
+    blamed = keys.size == 0 ? @semantic : @semantic.keys[0]
+
     keys.flatten!
     if keys.size == 0
-      fail(Puppet::Pops::Issues::BAD_TYPE_SLICE_ARITY, o,
-        :base_type => Puppet::Pops::Types::TypeCalculator.new().string(o), :min => 1, :actual => 0)
+      fail(Puppet::Pops::Issues::BAD_TYPE_SLICE_ARITY, blamed,
+        :base_type => Puppet::Pops::Types::TypeCalculator.new().string(o), :min => 1, :max => -1, :actual => 0)
     end
     if ! o.class_name.nil?
       # lookup class resource and return one or more parameter values
@@ -531,7 +535,8 @@ class Puppet::Pops::Evaluator::AccessOperator
     result = keys.each_with_index.map do |c, i|
       ctype = Puppet::Pops::Types::PHostClassType.new()
       if c.is_a?(Puppet::Pops::Types::PResourceType) && !c.type_name.nil? && c.title.nil?
-        c = c.type_name.downcase
+        # Remove leading '::' since all references are global, and 3x runtime does the wrong thing
+        c = c.type_name.downcase.sub(/^::/, '')
       end
       unless c.is_a?(String)
         fail(Puppet::Pops::Issues::ILLEGAL_HOSTCLASS_NAME, @semantic.keys[i], {:name => c})
@@ -539,7 +544,7 @@ class Puppet::Pops::Evaluator::AccessOperator
       if c !~ Puppet::Pops::Patterns::NAME
         fail(Issues::ILLEGAL_NAME, @semantic.keys[i], {:name=>c})
       end
-      ctype.class_name = c
+      ctype.class_name = c.downcase.sub(/^::/,'')
       ctype
     end
     # returns single type as type, else an array of types

data/lib/puppet/pops/issues.rb

@@ -384,7 +384,7 @@ module Puppet::Pops::Issues
     base_type_label = base_type.is_a?(String) ? base_type : label.a_an_uc(base_type)
     if max == -1 || max == 1.0 / 0.0 # Infinity
       "#{base_type_label}[] accepts #{min} or more arguments. Got #{actual}"
-    elsif max
+    elsif max && max != min
       "#{base_type_label}[] accepts #{min} to #{max} arguments. Got #{actual}"
     else
       "#{base_type_label}[] accepts #{min} #{label.plural_s(min, 'argument')}. Got #{actual}"

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

@@ -383,10 +383,8 @@ class Puppet::Pops::Types::TypeCalculator
   def instance_of_PTupleType(t, o)
     return false unless o.is_a?(Array)
     # compute the tuple's min/max size, and check if that size matches
-    from, to = size_range(t.size_type)
-    size_t = Types::PIntegerType.new()
-    size_t.from = t.types.size - 1 + from
-    size_t.to = t.types.size - 1 + to
+    size_t = t.size_type || Puppet::Pops::Types::TypeFactory.range(*t.size_range)
+
     # compute the array's size as type
     size_t2 = size_as_type(o)
     return false unless assignable?(size_t, size_t2)
@@ -915,39 +913,27 @@ class Puppet::Pops::Types::TypeCalculator
     end
   end
 
+  def max(a,b)
+    a >=b ? a : b
+  end
+
+  def min(a,b)
+    a <= b ? a : b
+  end
+
   def assignable_PTupleType(t, t2)
     return true if t == t2 || t.types.empty? && (t2.is_a?(Types::PArrayType))
-    t_regular = t.types[0..-2]
-    t_ranged = t.types[-1]
-    t_from, t_to = size_range(t.size_type)
-    t_required = t_regular.size + t_from
+    size_t = t.size_type || Puppet::Pops::Types::TypeFactory.range(*t.size_range)
 
     if t2.is_a?(Types::PTupleType)
-      t2_regular = t2.types[0..-2]
-      t2_ranged = t2.types[-1]
-      t2_from, t2_to = size_range(t2.size_type)
-      t2_required = t2_regular.size + t2_from
+      size_t2 = t2.size_type || Puppet::Pops::Types::TypeFactory.range(*t2.size_range)
 
-      # tuples with fewer required entries can not be assigned
-      return false if t_required > t2_required
-      # tuples with more optionally available entries can not be assigned
-      return false if t_regular.size + t_to < t2_regular.size + t2_to
-
-      t_required.times do |index|
-        t_entry = tuple_entry_at(t, t_from, t_to, index)
-        t2_entry = tuple_entry_at(t2, t2_from, t2_to, index)
-        return false if t2_entry.nil? || !assignable?(t_entry, t2_entry)
+      # not assignable if the number of types in t2 is outside number of types in t1
+      return false unless assignable?(size_t, size_t2)
+      max(t.types.size, t2.types.size).times do |index|
+        return false unless assignable?((t.types[index] || t.types[-1]), (t2.types[index] || t2.types[-1]))
       end
-      # Handle remainder in t2's required
-      (t2_required - t_required).times do |index|
-        t_entry = tuple_entry_at(t, t_from, t_to, t_required + index)
-        t2_entry = tuple_entry_at(t2, t2_from, t2_to, t_required + index)
-        return false if t2_entry.nil? || !assignable?(t_entry, t2_entry)
-      end
-      # Now only a trailing optional type remains - the last type must always be compatible
-      # irrespective of optionality and count
-      #
-      return assignable?(t_ranged, t2_ranged)
+      true
 
     elsif t2.is_a?(Types::PArrayType)
       t2_entry = t2.element_type
@@ -956,21 +942,15 @@ class Puppet::Pops::Types::TypeCalculator
       # was handled at the top of this method.
       #
       return false if t2_entry.nil?
-
-      # array type may be size constrained
-      size_t = t2.size_type || @collection_default_size_t
-      min, max = size_t.range
-      # Array with fewer min entries can not be assigned
-      return false if t_required > min
-      # Array with more optionally available entries can not be assigned
-      return false if t_regular.size + t_to < max
-      # each tuple type must be assignable to the element type
-      t_required.times do |index|
-        t_entry = tuple_entry_at(t, t_from, t_to, index)
-        return false unless assignable?(t_entry, t2_entry)
+      size_t = t.size_type || Puppet::Pops::Types::TypeFactory.range(*t.size_range)
+      size_t2 = t2.size_type || @collection_default_size_t
+      return false unless assignable?(size_t, size_t2)
+      min(t.types.size, size_t2.range()[1]).times do |index|
+        return false unless assignable?((t.types[index] || t.types[-1]), t2_entry)
       end
-      # ... and so must the last, possibly optional (ranged) type
-      return assignable?(t_ranged, t2_entry)
+      true
+    else
+      false
     end
   end
 

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

@@ -221,7 +221,9 @@ module Puppet::Pops::Types::TypeFactory
   #
   def self.host_class(class_name = nil)
     type = Types::PHostClassType.new()
-    type.class_name = class_name
+    unless class_name.nil?
+      type.class_name = class_name.sub(/^::/, '')
+    end
     type
   end
 

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

@@ -307,10 +307,33 @@ module Puppet::Pops::Types
   # @api public
   class PTupleType < PObjectType
     contains_many_uni 'types', PAbstractType, :lowerBound => 1
-    # If set, describes repetition of the last type in types
+    # If set, describes min and max required of the given types - if max > size of
+    # types, the last type entry repeats
+    #
     contains_one_uni 'size_type', PIntegerType, :lowerBound => 0
 
     module ClassModule
+      # Returns the number of elements accepted [min, max] in the tuple
+      def size_range
+        types_size = types.size
+        size_type.nil? ? [types_size, types_size] : size_type.range
+      end
+
+      # Returns the number of accepted occurrences [min, max] of the last type in the tuple
+      # The defaults is [1,1]
+      #
+      def repeat_last_range
+        types_size = types.size
+        if size_type.nil?
+          return [1, 1]
+        end
+        from, to = size_type.range()
+        min = from - (types_size-1)
+        min = min <= 0 ? 0 : min
+        max = to - (types_size-1)
+        [min, max]
+      end
+
       def hash
         [self.class, size_type, Set.new(types)].hash
       end
@@ -379,7 +402,7 @@ module Puppet::Pops::Types
     # contains_one_uni 'super_type', PHostClassType
     module ClassModule
       def hash
-        [self.class, host_class].hash
+        [self.class, class_name].hash
       end
       def ==(o)
         self.class == o.class && class_name == o.class_name

data/lib/puppet/provider/user/directoryservice.rb

@@ -370,6 +370,8 @@ Puppet::Type.type(:user).provide :directoryservice do
         if value.length != 256
            raise Puppet::Error, "OS X versions > 10.7 require a Salted SHA512 PBKDF2 password hash of 256 characters. Please check your password and try again."
         end
+
+        assert_full_pbkdf2_password
       end
 
       # Methods around setting the password on OS X are the ONLY methods that
@@ -405,6 +407,8 @@ Puppet::Type.type(:user).provide :directoryservice do
   # method.
   def iterations=(value)
     if (Puppet::Util::Package.versioncmp(self.class.get_os_version, '10.7') > 0)
+      assert_full_pbkdf2_password
+
       sleep 2
       flush_dscl_cache
       users_plist = get_users_plist(@resource.name)
@@ -420,6 +424,8 @@ Puppet::Type.type(:user).provide :directoryservice do
   # method.
   def salt=(value)
     if (Puppet::Util::Package.versioncmp(self.class.get_os_version, '10.7') > 0)
+      assert_full_pbkdf2_password
+
       sleep 2
       flush_dscl_cache
       users_plist = get_users_plist(@resource.name)
@@ -473,6 +479,14 @@ Puppet::Type.type(:user).provide :directoryservice do
   ## Helper Methods ##
   ##                ##
 
+  def assert_full_pbkdf2_password
+    missing = [:password, :salt, :iterations].select { |parameter| @resource[parameter].nil? }
+
+    if !missing.empty?
+       raise Puppet::Error, "OS X versions > 10\.7 use PBKDF2 password hashes, which requires all three of salt, iterations, and password hash. This resource is missing: #{missing.join(', ')}."
+    end
+  end
+
   def users_plist_dir
     '/var/db/dslocal/nodes/Default/users'
   end

data/lib/puppet/settings.rb

@@ -13,6 +13,7 @@ class Puppet::Settings
   require 'puppet/settings/enum_setting'
   require 'puppet/settings/file_setting'
   require 'puppet/settings/directory_setting'
+  require 'puppet/settings/file_or_directory_setting'
   require 'puppet/settings/path_setting'
   require 'puppet/settings/boolean_setting'
   require 'puppet/settings/terminus_setting'
@@ -639,6 +640,7 @@ class Puppet::Settings
       :string     => StringSetting,
       :file       => FileSetting,
       :directory  => DirectorySetting,
+      :file_or_directory => FileOrDirectorySetting,
       :path       => PathSetting,
       :boolean    => BooleanSetting,
       :terminus   => TerminusSetting,
@@ -1214,7 +1216,7 @@ Generated on #{Time.now}.
       return value unless value.is_a? String
       value.gsub(/\$(\w+)|\$\{(\w+)\}/) do |value|
         varname = $2 || $1
-        if varname == "environment"
+        if varname == "environment" && @environment
           @environment
         elsif varname == "run_mode"
           @mode

data/lib/puppet/settings/file_or_directory_setting.rb

@@ -0,0 +1,34 @@
+class Puppet::Settings::FileOrDirectorySetting < Puppet::Settings::FileSetting
+
+  def initialize(args)
+    super
+  end
+
+  def type
+    if Puppet::FileSystem.directory?(self.value) || @path_ends_with_slash
+      :directory
+    else
+      :file
+    end
+  end
+
+  # Overrides munge to be able to read the un-munged value (the FileSetting.munch removes trailing slash)
+  #
+  def munge(value)
+    if value.is_a?(String) && value =~ /[\\\/]$/
+      @path_ends_with_slash = true
+    end
+    super
+  end
+
+  # @api private
+  def open_file(filename, option = 'r', &block)
+    if type == :file
+      super
+    else
+      controlled_access do |mode|
+        Puppet::FileSystem.open(filename, mode, option, &block)
+      end
+    end
+  end
+end

data/lib/puppet/type/user.rb

@@ -189,6 +189,9 @@ module Puppet
         * Mac OS X 10.7 (Lion) uses salted SHA512 hashes. The Puppet Labs [stdlib][]
           module contains a `str2saltedsha512` function which can generate password
           hashes for Lion.
+        * Mac OS X 10.8 and higher use salted SHA512 PBKDF2 hashes. When
+          managing passwords on these systems the salt and iterations properties
+          need to be specified as well as the password.
         * Windows passwords can only be managed in cleartext, as there is no Windows API
           for setting the password hash.
 
@@ -544,13 +547,13 @@ module Puppet
 
     newproperty(:salt, :required_features => :manages_password_salt) do
       desc "This is the 32 byte salt used to generate the PBKDF2 password used in
-            OS X"
+            OS X. This field is required for managing passwords on OS X >= 10.8."
     end
 
     newproperty(:iterations, :required_features => :manages_password_salt) do
       desc "This is the number of iterations of a chained computation of the
             password hash (http://en.wikipedia.org/wiki/PBKDF2).  This parameter
-            is used in OS X"
+            is used in OS X. This field is required for managing passwords on OS X >= 10.8."
 
       munge do |value|
         if value.is_a?(String) and value =~/^[-0-9]+$/

data/lib/puppet/version.rb

@@ -7,7 +7,7 @@
 
 
 module Puppet
-  PUPPETVERSION = '3.5.0-rc1'
+  PUPPETVERSION = '3.5.0-rc2'
 
   ##
   # version is a public API method intended to always provide a fast and

data/spec/integration/indirector/direct_file_server_spec.rb

@@ -1,5 +1,5 @@
-#! /usr/bin/env ruby
 require 'spec_helper'
+require 'matchers/include'
 
 require 'puppet/indirector/file_content/file'
 
@@ -34,34 +34,31 @@ end
 
 describe Puppet::Indirector::DirectFileServer, " when interacting with FileServing::Fileset and the model" do
   include PuppetSpec::Files
+  include Matchers::Include
 
-  let(:path) { tmpdir('direct_file_server_testing') }
+  matcher :file_with_content do |name, content|
+    match do |actual|
+      actual.full_path == name && actual.content == content
+    end
+  end
 
-  before do
-    @terminus = Puppet::Indirector::FileContent::File.new
+  matcher :directory_named do |name|
+    match do |actual|
+      actual.full_path == name
+    end
+  end
 
+  it "should return an instance for every file in the fileset" do
+    path = tmpdir('direct_file_server_testing')
     File.open(File.join(path, "one"), "w") { |f| f.print "one content" }
     File.open(File.join(path, "two"), "w") { |f| f.print "two content" }
 
-    @request = @terminus.indirection.request(:search, "file:///#{path}", nil, :recurse => true)
-  end
-
-  it "should return an instance for every file in the fileset" do
-    result = @terminus.search(@request)
-    result.should be_instance_of(Array)
-    result.length.should == 3
-    result.each { |r| r.should be_instance_of(Puppet::FileServing::Content) }
-  end
+    terminus = Puppet::Indirector::FileContent::File.new
+    request = terminus.indirection.request(:search, "file:///#{path}", nil, :recurse => true)
 
-  it "should return instances capable of returning their content" do
-    @terminus.search(@request).each do |instance|
-      case instance.full_path
-      when /one/; instance.content.should == "one content"
-      when /two/; instance.content.should == "two content"
-      when path
-      else
-        raise "No valid key for #{instance.path.inspect}"
-      end
-    end
+    expect(terminus.search(request)).to include_in_any_order(
+      file_with_content(File.join(path, "one"), "one content"),
+      file_with_content(File.join(path, "two"), "two content"),
+      directory_named(path))
   end
 end