puppet 4.8.0-x64-mingw32 → 4.8.1-x64-mingw32

data/Gemfile

@@ -53,6 +53,9 @@ group(:development, :test) do
 
   gem 'rdoc', "~> 4.1", :platforms => [:ruby]
 
+  # webmock requires addressable as as of 2.5.0 addressable started
+  # requiring the public_suffix gem which requires Ruby 2
+  gem 'addressable', '< 2.5.0'
   gem 'webmock', '~> 1.24'
   gem 'vcr', '~> 2.9'
 end

data/MAINTAINERS

@@ -9,11 +9,6 @@
       "email": "henrik.lindberg@puppet.com",
       "name": "Henrik Lindberg"
     },
-    {
-      "github": "kylog",
-      "email": "kylo@puppet.com",
-      "name": "Kylo Ginsberg"
-    },
     {
       "github": "joshcooper",
       "email": "josh@puppet.com",

data/Rakefile

@@ -84,7 +84,7 @@ task(:commits) do
   # falls back to `master..HEAD` as a next best bet as `master` is unlikely to
   # ever be absent.
   commit_range = ENV['TRAVIS_COMMIT_RANGE'].nil? ? 'master..HEAD' : ENV['TRAVIS_COMMIT_RANGE']
-  puts "Checking commits..."
+  puts "Checking commits #{commit_range}"
   %x{git log --no-merges --pretty=%s #{commit_range}}.each_line do |commit_summary|
     # This regex tests for the currently supported commit summary tokens: maint, doc, packaging, or pup-<number>.
     # The exception tries to explain it in more full.

data/lib/puppet/face/config.rb

@@ -108,7 +108,7 @@ Puppet::Face.define(:config, '0.0.1') do
     when_invoked do |name, value, options|
       path = Puppet::FileSystem.pathname(Puppet.settings.which_configuration_file)
       Puppet::FileSystem.touch(path)
-      Puppet::FileSystem.open(path, nil, 'r+') do |file|
+      Puppet::FileSystem.open(path, nil, 'r+:UTF-8') do |file|
         Puppet::Settings::IniFile.update(file) do |config|
           config.set(options[:section], name, value)
         end

data/lib/puppet/provider/mount/parsed.rb

@@ -209,20 +209,14 @@ Puppet::Type.type(:mount).provide(
 
     # Update fstab entries that are mounted
     providers.each do |prov|
-      mounts.delete_if do |mount|
-        if mount[:name] == prov.get(:name) && mount[:mounted] == :yes
-          prov.set(:ensure => :mounted)
-          prov.set(:live_options => mount[:live_options])
-          true
-        else
-          false
-        end
+      if mounts.delete({:name => prov.get(:name), :mounted => :yes}) then
+        prov.set(:ensure => :mounted)
       end
     end
 
     # Add mounts that are not in fstab but mounted
     mounts.each do |mount|
-      providers << new(:ensure => :ghost, :name => mount[:name], :live_options => mount[:live_options])
+      providers << new(:ensure => :ghost, :name => mount[:name])
     end
     providers
   end
@@ -238,7 +232,6 @@ Puppet::Type.type(:mount).provide(
     #   to fstab we need to know if the device was mounted before)
     mountinstances.each do |hash|
       if mount = resources[hash[:name]]
-        mount.provider.set(:live_options => hash[:live_options])
         case mount.provider.get(:ensure)
         when :absent  # Mount not in fstab
           mount.provider.set(:ensure => :ghost)
@@ -261,7 +254,6 @@ Puppet::Type.type(:mount).provide(
       else
         / on (\S*)/
     end
-
     instances = []
     mount_output = mountcmd.split("\n")
     if mount_output.length >= 2 and mount_output[1] =~ /^[- \t]*$/
@@ -272,13 +264,7 @@ Puppet::Type.type(:mount).provide(
     end
     mount_output.each do |line|
       if match = regex.match(line) and name = match.captures.first
-        live_options_platforms = ["Linux", "Darwin"]
-        if live_options_platforms.include? Facter.value(:kernel)
-          options = line[/\(.*\)/].tr('()', '')
-          instances << {:name => name, :mounted => :yes, :live_options => options}
-        else
-          instances << {:name => name, :mounted => :yes}
-        end
+        instances << {:name => name, :mounted => :yes} # Only :name is important here
       else
         raise Puppet::Error, "Could not understand line #{line} from mount output"
       end

data/lib/puppet/settings/ini_file.rb

@@ -13,9 +13,9 @@ class Puppet::Settings::IniFile
     config = new([DefaultSection.new])
     config_fh.each_line do |line|
       case line
-      when /^(\s*)\[(\w+)\](\s*)$/
+      when /^(\s*)\[([[:word:]]+)\](\s*)$/
         config.append(SectionLine.new($1, $2, $3))
-      when /^(\s*)(\w+)(\s*=\s*)(.*?)(\s*)$/
+      when /^(\s*)([[:word:]]+)(\s*=\s*)(.*?)(\s*)$/
         config.append(SettingLine.new($1, $2, $3, $4, $5))
       else
         config.append(Line.new(line))

data/lib/puppet/type/mount.rb

@@ -176,50 +176,6 @@ module Puppet
         appear in fstab. For many platforms this is a comma delimited string.
         Consult the fstab(5) man page for system-specific details."
 
-          def insync?(is)
-
-            if @resource[:ensure] == :mounted && !provider.property_hash[:live_options].nil?
-
-              # The mount options according to /etc/fstab. It is possible for puppet to
-              # update this file to reflect new options even if the remount to update
-              # the options has actually failed
-              fstab_options = provider.property_hash[:options] || ''
-              # The mount options according to the output of the 'mount' command. These will
-              # always reflect the options of the actual mounted device
-              mount_options = provider.property_hash[:live_options] || ''
-              # The desired mount options that have been specified in the puppet manifest
-              resource_options = @resource[:options] || ''
-
-              mount_list = mount_options.split(',')
-              resource_list = resource_options.split(',')
-              # Remove the string 'defaults' from the list of resources, because when
-              # we are comparing against the mount command output 'defaults' will be
-              # expanded into the full list of default options for the OS and file system
-              resource_list.delete('defaults')
-
-              # Do the options in fstab match the options that the user has defined?
-              if fstab_options != resource_options
-                return false
-              end
-
-              # Do the options provided by the 'mount' command match the options that
-              # the user has defined? We have to check this too because fstab could provide
-              # a false positive if a remount has failed
-              #
-              # We want to see if the mount command options contain the list of user
-              # specified options from the manifest. The reason we cannot do a 1:1
-              # comparison is because the expanded list of default options may be included
-              # in the mount output. These vary between OS and file system so since we don't
-              # have a good way to find out what they are, just check for the specific options
-              # the user has specified
-              if !(resource_list - mount_list).empty?
-                return false
-              end
-            end
-
-            super
-          end
-
       validate do |value|
         raise Puppet::Error, "options must not contain whitespace: #{value}" if value =~ /\s/
         raise Puppet::Error, "options must not be an empty string" if value.empty?

data/lib/puppet/version.rb

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

data/spec/integration/faces/config_spec.rb

@@ -0,0 +1,80 @@
+#! /usr/bin/env ruby
+require 'spec_helper'
+require 'puppet/face'
+
+describe Puppet::Face[:config, '0.0.1'] do
+  include PuppetSpec::Files
+
+  # different UTF-8 widths
+  # 1-byte A
+  # 2-byte ۿ - http://www.fileformat.info/info/unicode/char/06ff/index.htm - 0xDB 0xBF / 219 191
+  # 3-byte ᚠ - http://www.fileformat.info/info/unicode/char/16A0/index.htm - 0xE1 0x9A 0xA0 / 225 154 160
+  # 4-byte 𠜎 - http://www.fileformat.info/info/unicode/char/2070E/index.htm - 0xF0 0xA0 0x9C 0x8E / 240 160 156 142
+  MIXED_UTF8 = "A\u06FF\u16A0\u{2070E}" # Aۿᚠ𠜎
+  let (:tmp_environment_path) { tmpdir('envpath') }
+  let (:tmp_config) { tmpfile('puppet.conf') }
+
+  def load_settings(path)
+    test_settings = Puppet::Settings.new
+
+    test_settings.define_settings(:main,
+      :config => {
+        :type => :file,
+        :default => path,
+        :desc => '',
+      },
+      :environmentpath => {
+        :default => tmp_environment_path,
+        :desc => '',
+      },
+      :basemodulepath => {
+        :default => '',
+        :desc => '',
+      },
+      # definition required to use the value
+      :rando_key => {
+        :default => '',
+        :desc => ''
+      },
+      MIXED_UTF8.to_sym => {
+        :default => '',
+        :desc => ''
+      },
+    )
+
+    test_settings.initialize_global_settings
+    test_settings
+  end
+
+  before :each do
+    File.open(tmp_config, 'w', :encoding => 'UTF-8') do |file|
+      file.puts <<-EOF
+[main]
+rando_key=foobar
+#{MIXED_UTF8}=foobar
+      EOF
+    end
+  end
+
+  context 'when getting / setting UTF8 values' do
+    # key must be a defined setting
+    ['rando_key', MIXED_UTF8].each do |key|
+      it "can change '#{key}' keyed ASCII value to a UTF-8 value and read it back" do
+        key = "rando_key"
+        value = "value#{MIXED_UTF8.reverse}value"
+
+        # needed for the subject.set to write to correct file
+        Puppet.settings.stubs(:which_configuration_file).returns(tmp_config)
+        subject.set(key, value)
+
+        # make sure subject.print looks at the newly modified settings
+        test_settings = load_settings(tmp_config)
+        # instead of the default Puppet.settings (implementation detail)
+        Puppet.stubs(:settings).returns(test_settings)
+
+        expect { subject.print() }.to have_printed("#{key} = #{value}")
+        expect { subject.print(key, :section => 'main') }.to have_printed("#{value}")
+      end
+    end
+  end
+end

data/spec/integration/provider/mount_spec.rb

@@ -149,10 +149,9 @@ describe "mount provider (integration)", :unless => Puppet.features.microsoft_wi
       pending "Due to bug 6309"
       @mounted = true
       @current_device = "/dev/disk2s2"
-      @current_options = "local"
       create_fake_fstab(true)
       @desired_options = "local"
-      run_in_catalog(:ensure=>:mounted, :options=>'msdos,local')
+      run_in_catalog(:ensure=>:mounted, :options=>'local')
       expect(@current_device).to eq("/dev/disk1s1")
       expect(@mounted).to eq(true)
       expect(@current_options).to eq('local')

data/spec/integration/util/windows/principal_spec.rb

@@ -8,7 +8,7 @@ describe Puppet::Util::Windows::SID::Principal, :if => Puppet.features.microsoft
   let (:system_bytes) { [1, 1, 0, 0, 0, 0, 0, 5, 18, 0, 0, 0] }
   let (:null_sid_bytes) { bytes = [1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0] }
   let (:administrator_bytes) { [1, 2, 0, 0, 0, 0, 0, 5, 32, 0, 0, 0, 32, 2, 0, 0] }
-  let (:computer_sid) { Puppet::Util::Windows::SID.name_to_sid_object(Socket.gethostname) }
+  let (:computer_sid) { Puppet::Util::Windows::SID.name_to_sid_object(Puppet::Util::Windows::ADSI.computer_name) }
   # BUILTIN is localized on German Windows, but not French
   # looking this up like this dilutes the values of the tests as we're comparing two mechanisms
   # for returning the same values, rather than to a known good
@@ -64,7 +64,7 @@ describe Puppet::Util::Windows::SID::Principal, :if => Puppet.features.microsoft
       # otherwise running in AppVeyor there is no Administrator and a the current local user can be used
       skip if (running_as_system && !user_exists)
 
-      hostname = Socket.gethostname
+      hostname = Puppet::Util::Windows::ADSI.computer_name
 
       principal = Puppet::Util::Windows::SID::Principal.lookup_account_name("#{hostname}\\#{username}")
       expect(principal.account).to match(/^#{Regexp.quote(username)}$/i)

data/spec/unit/face/config_spec.rb

@@ -44,6 +44,53 @@ syslogfacility = file
     subject.print('all')
   end
 
+  context "when setting config values" do
+    let(:config_file) { '/foo/puppet.conf' }
+    let(:path) { Pathname.new(config_file).expand_path }
+    before(:each) do
+      Puppet[:config] = config_file
+      Puppet::FileSystem.stubs(:pathname).with(path.to_s).returns(path)
+      Puppet::FileSystem.stubs(:touch)
+    end
+
+    it "writes to the correct puppet config file" do
+      Puppet::FileSystem.expects(:open).with(path, anything, anything)
+      subject.set('foo', 'bar')
+    end
+
+    it "creates a config file if one does not exist" do
+      Puppet::FileSystem.stubs(:open).with(path, anything, anything).yields(StringIO.new)
+      Puppet::FileSystem.expects(:touch).with(path)
+      subject.set('foo', 'bar')
+    end
+
+    it "sets the supplied config/value in the default section (main)" do
+      Puppet::FileSystem.stubs(:open).with(path, anything, anything).yields(StringIO.new)
+      config = Puppet::Settings::IniFile.new([Puppet::Settings::IniFile::DefaultSection.new])
+      manipulator = Puppet::Settings::IniFile::Manipulator.new(config)
+      Puppet::Settings::IniFile::Manipulator.stubs(:new).returns(manipulator)
+
+      manipulator.expects(:set).with("main", "foo", "bar")
+      subject.set('foo', 'bar')
+    end
+
+    it "sets the value in the supplied section" do
+      Puppet::FileSystem.stubs(:open).with(path, anything, anything).yields(StringIO.new)
+      config = Puppet::Settings::IniFile.new([Puppet::Settings::IniFile::DefaultSection.new])
+      manipulator = Puppet::Settings::IniFile::Manipulator.new(config)
+      Puppet::Settings::IniFile::Manipulator.stubs(:new).returns(manipulator)
+
+      manipulator.expects(:set).with("baz", "foo", "bar")
+      subject.set('foo', 'bar', {:section => "baz"})
+
+    end
+
+    it "opens the file with UTF-8 encoding" do
+      Puppet::FileSystem.expects(:open).with(path, nil, 'r+:UTF-8')
+      subject.set('foo', 'bar')
+    end
+  end
+
   shared_examples_for :config_printing_a_section do |section|
 
     def add_section_option(args, section)

data/spec/unit/provider/mount/parsed_spec.rb

@@ -115,7 +115,6 @@ FSTAB
   describe "mountinstances" do
     it "should get name from mountoutput found on Solaris" do
       Facter.stubs(:value).with(:osfamily).returns 'Solaris'
-      Facter.stubs(:value).with(:kernel).returns 'SunOS'
       described_class.stubs(:mountcmd).returns(File.read(my_fixture('solaris.mount')))
       mounts = described_class.mountinstances
       expect(mounts.size).to eq(6)
@@ -129,7 +128,6 @@ FSTAB
 
     it "should get name from mountoutput found on HP-UX" do
       Facter.stubs(:value).with(:osfamily).returns 'HP-UX'
-      Facter.stubs(:value).with(:kernel).returns 'HP-UX'
       described_class.stubs(:mountcmd).returns(File.read(my_fixture('hpux.mount')))
       mounts = described_class.mountinstances
       expect(mounts.size).to eq(17)
@@ -152,35 +150,32 @@ FSTAB
       expect(mounts[16]).to eq({ :name => '/ghost', :mounted => :yes })
     end
 
-    it "should get name and mount options from mountoutput found on Darwin" do
+    it "should get name from mountoutput found on Darwin" do
       Facter.stubs(:value).with(:osfamily).returns 'Darwin'
-      Facter.stubs(:value).with(:kernel).returns 'Darwin'
       described_class.stubs(:mountcmd).returns(File.read(my_fixture('darwin.mount')))
       mounts = described_class.mountinstances
       expect(mounts.size).to eq(6)
-      expect(mounts[0]).to eq({ :name => '/', :mounted => :yes, :live_options=>"hfs, local, journaled"})
-      expect(mounts[1]).to eq({ :name => '/dev', :mounted => :yes, :live_options=>"devfs, local, nobrowse"})
-      expect(mounts[2]).to eq({ :name => '/net', :mounted => :yes, :live_options=>"autofs, nosuid, automounted, nobrowse"})
-      expect(mounts[3]).to eq({ :name => '/home', :mounted => :yes, :mounted=>:yes, :live_options=>"autofs, automounted, nobrowse"})
-      expect(mounts[4]).to eq({ :name => '/usr', :mounted => :yes, :mounted=>:yes, :live_options=>"hfs, local, journaled"})
-      expect(mounts[5]).to eq({ :name => '/ghost', :mounted => :yes, :live_options => "hfs, local, journaled"})
+      expect(mounts[0]).to eq({ :name => '/', :mounted => :yes })
+      expect(mounts[1]).to eq({ :name => '/dev', :mounted => :yes })
+      expect(mounts[2]).to eq({ :name => '/net', :mounted => :yes })
+      expect(mounts[3]).to eq({ :name => '/home', :mounted => :yes })
+      expect(mounts[4]).to eq({ :name => '/usr', :mounted => :yes })
+      expect(mounts[5]).to eq({ :name => '/ghost', :mounted => :yes })
     end
 
-    it "should get name and mount options from mountoutput found on Linux" do
+    it "should get name from mountoutput found on Linux" do
       Facter.stubs(:value).with(:osfamily).returns 'Gentoo'
-      Facter.stubs(:value).with(:kernel).returns 'Linux'
       described_class.stubs(:mountcmd).returns(File.read(my_fixture('linux.mount')))
       mounts = described_class.mountinstances
-      expect(mounts[0]).to eq({ :name => '/', :mounted => :yes, :live_options=>"rw,noatime"})
-      expect(mounts[1]).to eq({ :name => '/lib64/rc/init.d', :mounted => :yes, :live_options => "rw,nosuid,nodev,noexec,relatime,size=1024k,mode=755" })
-      expect(mounts[2]).to eq({ :name => '/sys', :mounted => :yes, :live_options => "rw,nosuid,nodev,noexec,relatime"})
-      expect(mounts[3]).to eq({ :name => '/usr/portage', :mounted => :yes, :live_options => "rw" })
-      expect(mounts[4]).to eq({ :name => '/ghost', :mounted => :yes, :live_options => "rw" })
+      expect(mounts[0]).to eq({ :name => '/', :mounted => :yes })
+      expect(mounts[1]).to eq({ :name => '/lib64/rc/init.d', :mounted => :yes })
+      expect(mounts[2]).to eq({ :name => '/sys', :mounted => :yes })
+      expect(mounts[3]).to eq({ :name => '/usr/portage', :mounted => :yes })
+      expect(mounts[4]).to eq({ :name => '/ghost', :mounted => :yes })
     end
 
     it "should get name from mountoutput found on AIX" do
       Facter.stubs(:value).with(:osfamily).returns 'AIX'
-      Facter.stubs(:value).with(:kernel).returns 'AIX'
       described_class.stubs(:mountcmd).returns(File.read(my_fixture('aix.mount')))
       mounts = described_class.mountinstances
       expect(mounts[0]).to eq({ :name => '/', :mounted => :yes })
@@ -229,42 +224,29 @@ FSTAB
           platform != 'solaris' or
             skip "We need to stub the operatingsystem fact at load time, but can't"
         end
+
+        # Stub the mount output to our fixture.
+        begin
+          mount = my_fixture(platform + '.mount')
+          described_class.stubs(:mountcmd).returns File.read(mount)
+        rescue
+          skip "is #{platform}.mount missing at this point?"
+        end
+
+        # Note: we have to stub default_target before creating resources
+        # because it is used by Puppet::Type::Mount.new to populate the
+        # :target property.
+        described_class.stubs(:default_target).returns fstab
+        @retrieve = described_class.instances.collect { |prov| {:name => prov.get(:name), :ensure => prov.get(:ensure)}}
       end
 
       # Following mountpoint are present in all fstabs/mountoutputs
       describe "on other platforms than Solaris", :if => Facter.value(:osfamily) != 'Solaris' do
-        before :each do
-          # Stub the mount output to our fixture.
-          begin
-            mount = my_fixture(platform + '.mount')
-            described_class.stubs(:mountcmd).returns File.read(mount)
-          rescue
-            skip "is #{platform}.mount missing at this point?"
-          end
-
-          # Note: we have to stub default_target before creating resources
-          # because it is used by Puppet::Type::Mount.new to populate the
-          # :target property.
-          described_class.stubs(:default_target).returns fstab
-
-          platforms = {
-            'linux' => ['Gentoo', 'Linux'],
-            'freebsd' => ['BSD', 'BSD'],
-            'openbsd' => ['BSD', 'BSD'],
-            'netbsd' => ['BSd', 'BSD']
-          }
-          Facter.stubs(:value).with(:osfamily).returns(platforms[platform][0])
-          Facter.stubs(:value).with(:kernel).returns(platforms[platform][1])
-
-          @retrieve = described_class.instances.collect { |prov| {:name => prov.get(:name), :ensure => prov.get(:ensure)}}
-        end
-        
-        it "should include mounted resources" do
+        it "should include unmounted resources" do
           expect(@retrieve).to include(:name => '/', :ensure => :mounted)
         end
 
-        it "should include unmounted resources" do
-        @retrieve = described_class.instances.collect { |prov| {:name => prov.get(:name), :ensure => prov.get(:ensure)}}
+        it "should include mounted resources" do
           expect(@retrieve).to include(:name => '/boot', :ensure => :unmounted)
         end