puppet 4.4.2 → 4.5.0

data/lib/puppet/type/tidy.rb

@@ -56,10 +56,10 @@ Puppet::Type.newtype(:tidy) do
 
       Example:
 
-          tidy { "/tmp":
-            age     => "1w",
+          tidy { '/tmp':
+            age     => '1w',
             recurse => 1,
-            matches => [ "[0-9]pub*.tmp", "*.temp", "tmpfile?" ]
+            matches => [ '[0-9]pub*.tmp', '*.temp', 'tmpfile?' ],
           }
 
       This removes files from `/tmp` if they are one week old or older,

data/lib/puppet/type/zone.rb

@@ -282,11 +282,11 @@ end
 
       And then call that:
 
-          zone { myzone:
-            ip           => "bge0:192.168.0.23",
-            sysidcfg     => template("site/sysidcfg.erb"),
-            path         => "/opt/zones/myzone",
-            realhostname => "fully.qualified.domain.name"
+          zone { 'myzone':
+            ip           => 'bge0:192.168.0.23',
+            sysidcfg     => template('site/sysidcfg.erb'),
+            path         => '/opt/zones/myzone',
+            realhostname => 'fully.qualified.domain.name',
           }
 
       The `sysidcfg` only matters on the first booting of the zone,

data/lib/puppet/util/feature.rb

@@ -32,7 +32,7 @@ class Puppet::Util::Feature
       #    configured to always cache
       if block_given?     ||
           @results[name]  ||
-          (@results.has_key?(name) and Puppet[:always_cache_features])
+          (@results.has_key?(name) && (Puppet[:always_cache_features] || !Puppet[:always_retry_plugins]))
         @results[name]
       else
         @results[name] = test(name, options)

data/lib/puppet/util/monkey_patches.rb

@@ -20,6 +20,14 @@ end
 
 class Symbol
   def <=> (other)
+    if (other.class != Symbol)
+      case Puppet[:strict]
+      when :warning
+        Puppet.warn_once('deprecation', 'symbol_comparison', 'Comparing Symbols to non-Symbol values is deprecated')
+      when :error
+        raise ArgumentError.new("Comparing Symbols to non-Symbol values is no longer allowed")
+      end
+    end
     self.to_s <=> other.to_s
   end
 

data/lib/puppet/util/network_device/cisco/device.rb

@@ -47,7 +47,13 @@ class Puppet::Util::NetworkDevice::Cisco::Device < Puppet::Util::NetworkDevice::
   end
 
   def execute(cmd)
-    transport.command(cmd)
+    transport.command(cmd) do |out|
+      if out =~ /^%/mo or out =~ /^Command rejected:/mo
+        # strip off the command just sent
+        error = out.sub(cmd,'')
+        Puppet.err "Error while executing '#{cmd}', device returned: #{error}"
+      end
+    end
   end
 
   def login
@@ -209,6 +215,12 @@ class Puppet::Util::NetworkDevice::Cisco::Device < Puppet::Util::NetworkDevice::
       return
     end
 
+    # Cisco VLANs are supposed to be alphanumeric only
+    if should[:description] =~ /[^\w]/
+      Puppet.err "Invalid VLAN name '#{should[:description]}' for Cisco device.\nVLAN name must be alphanumeric, no spaces or special characters."
+      return
+    end
+    
     # We're creating or updating an entry
     execute("conf t")
     execute("vlan #{id}")
@@ -250,12 +262,10 @@ class Puppet::Util::NetworkDevice::Cisco::Device < Puppet::Util::NetworkDevice::
         else
           raise "Unknown switchport encapsulation: #{$1} for #{interface}"
         end
-      when /^Access Mode VLAN:\s+(.*) \(\(Inactive\)\)$/
-        # nothing
-      when /^Access Mode VLAN:\s+(.*) \(.*\)$/
-        trunking[:access_vlan] = $1 if trunking[:mode] != :trunk
+      when /^Access Mode VLAN:\s+(.*) \((.*)\)$/
+        trunking[:access_vlan] = $1 if $2 != '(Inactive)'
       when /^Trunking Native Mode VLAN:\s+(.*) \(.*\)$/
-        trunking[:native_vlan] = $1 if trunking[:mode] != :access
+        trunking[:native_vlan] = $1
       when /^Trunking VLANs Enabled:\s+(.*)$/
         next if trunking[:mode] == :access
         vlans = $1

data/lib/puppet/util/network_device/cisco/interface.rb

@@ -45,11 +45,6 @@ class Puppet::Util::NetworkDevice::Cisco::Interface
         should[:access_vlan] = should[:native_vlan]
       end
 
-      # Don't change non-operational mode parameters
-      next if property == :access_vlan and should[:mode] == :trunk
-      next if property == :native_vlan and should[:mode] == :access
-      next if property == :encapsulation and should[:mode] == :access
-
       Puppet.debug("comparing #{property}: #{is[property]} == #{should[property]}")
 
       # They're equal, so do nothing.
@@ -89,7 +84,11 @@ class Puppet::Util::NetworkDevice::Cisco::Interface
 
   def command(command)
     transport.command(command) do |out|
-      Puppet.err "Error while executing #{command}, device returned #{out}" if out =~ /^%/mo
+      if out =~ /^%/mo or out =~ /^Command rejected:/mo
+        # strip off the command just sent
+        error = out.sub(command,'')
+        Puppet.err "Error while executing '#{command}', device returned: #{error}"
+      end
     end
   end
 end

data/lib/puppet/util/plist.rb

@@ -115,16 +115,16 @@ module Puppet::Util::Plist
       begin
         plist_to_save       = CFPropertyList::List.new
         plist_to_save.value = CFPropertyList.guess(plist)
-        plist_to_save.save(file_path, to_format(format))
+        plist_to_save.save(file_path, to_format(format), :formatted => true)
       rescue IOError => e
-        Puppet.error("Unable to write the file #{file_path}. #{e.inspect}")
+        Puppet.err("Unable to write the file #{file_path}. #{e.inspect}")
       end
     end
 
     def dump_plist(plist_data, format = :xml)
       plist_to_save       = CFPropertyList::List.new
       plist_to_save.value = CFPropertyList.guess(plist_data)
-      plist_to_save.to_str(to_format(format))
+      plist_to_save.to_str(to_format(format), :formatted => true)
     end
   end
 end

data/lib/puppet/version.rb

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

data/spec/fixtures/unit/application/environments/production/data/common.yaml

@@ -3,5 +3,18 @@ a: This is A
 b: This is B
 c: "This is%{cx}"
 
+d:
+  one:
+    two:
+      three: the value
+
+e.one.two.three: the value
+
+f.one:
+  two.three:
+    - first value
+    - second value
+    - third value
+
 lookup_options:
   a: first

data/spec/fixtures/unit/data_providers/environments/production/modules/abc/lib/puppet/functions/abc/data.rb

@@ -2,7 +2,8 @@ Puppet::Functions.create_function(:'abc::data') do
   def data()
     { 'abc::def::test1' => 'module_test1',
       'abc::def::test2' => 'module_test2',
-      'abc::def::test3' => 'module_test3'
+      'abc::def::test3' => 'module_test3',
+      'abc::def::ipl' => '%{lookup("abc::def::test2")}-ipl'
     }
   end
 end

data/spec/fixtures/unit/data_providers/environments/production/modules/abc/manifests/init.pp

@@ -2,8 +2,9 @@ class abc {
   include 'abc::def'
 }
 
-class abc::def ($test1, $test2, $test3) {
+class abc::def ($test1, $test2, $test3, $ipl ) {
   notify { $test1: }
   notify { $test2: }
   notify { $test3: }
+  notify { $ipl: }
 }

data/spec/fixtures/unit/functions/lookup/environments/production/modules/empty_key_json/data/empty_key.json

@@ -0,0 +1 @@
+{ "empty_key_json::has_undef_value": null }

data/spec/fixtures/unit/functions/lookup/environments/production/modules/empty_key_json/hiera.yaml

@@ -0,0 +1,5 @@
+---
+:version: 4
+:hierarchy:
+  - :name: empty_key
+    :backend: json

data/spec/fixtures/unit/functions/lookup/environments/production/modules/empty_key_json/manifests/init.pp

@@ -0,0 +1,2 @@
+class empty_key_json {
+}

data/spec/fixtures/unit/functions/lookup/environments/production/modules/empty_key_json/metadata.json

@@ -0,0 +1,9 @@
+{
+    "name": "example/empty_key_json",
+    "version": "0.0.2",
+    "source": "git@github.com/example/example-empty_key_json.git",
+    "dependencies": [],
+    "author": "Bob the Builder",
+    "license": "Apache-2.0",
+    "data_provider": "hiera"
+}

data/spec/fixtures/unit/functions/lookup/environments/production/modules/empty_key_yaml/data/empty_key.yaml

@@ -0,0 +1 @@
+empty_key_yaml::has_undef_value: ~

data/spec/fixtures/unit/functions/lookup/environments/production/modules/empty_key_yaml/hiera.yaml

@@ -0,0 +1,5 @@
+---
+:version: 4
+:hierarchy:
+  - :name: empty_key
+    :backend: yaml

data/spec/fixtures/unit/functions/lookup/environments/production/modules/empty_key_yaml/manifests/init.pp

@@ -0,0 +1,2 @@
+class empty_key_yaml {
+}

data/spec/fixtures/unit/functions/lookup/environments/production/modules/empty_key_yaml/metadata.json

@@ -0,0 +1,9 @@
+{
+    "name": "example/empty_key_yaml",
+    "version": "0.0.2",
+    "source": "git@github.com/example/example-empty_key_yaml.git",
+    "dependencies": [],
+    "author": "Bob the Builder",
+    "license": "Apache-2.0",
+    "data_provider": "hiera"
+}

data/spec/fixtures/unit/functions/lookup/environments/production/modules/empty_yaml/data/empty.yaml

@@ -1 +1,2 @@
 ---
+empty_key: ~

data/spec/fixtures/unit/pops/loaders/loaders/dependent_modules_with_metadata/modules/usee/lib/puppet/type/usee_type.rb

@@ -0,0 +1,5 @@
+Puppet::Type.newtype(:usee_type) do
+  newparam(:name, :namevar => true) do
+    desc 'An arbitrary name used as the identity of the resource.'
+  end
+end

data/spec/fixtures/unit/pops/loaders/loaders/dependent_modules_with_metadata/modules/user/manifests/init.pp

@@ -11,6 +11,12 @@ function puppet_init_calling_ruby() {
 }
 
 class user {
+  # Dummy resource. Added just to assert that a ruby type in another module is loaded correctly
+  # by the auto loader
+  Usee_type {
+    name => 'pelle'
+  }
+
   case $::case_number {
     1: {
       # Call a puppet function that resides in usee/functions directly from init.pp

data/spec/fixtures/unit/provider/service/smf/svcs.out

@@ -1,3 +1,4 @@
-legacy_run     16:19:12 lrc:/etc/rcS_d/S50sk98sol
-online         16:19:08 svc:/system/svc/restarter:default
-maintenance    16:19:13 svc:/network/cswrsyncd:default
+legacy_run    lrc:/etc/rcS_d/S50sk98sol
+online        svc:/system/svc/restarter:default
+maintenance   svc:/network/cswrsyncd:default
+degraded      svc:/network/dns/client:default

data/spec/integration/module_tool/tar/mini_spec.rb

@@ -1,28 +1,28 @@
-require 'spec_helper'
-require 'puppet/module_tool'
-require 'puppet_spec/files'
-
-describe Puppet::ModuleTool::Tar::Mini, :if => (Puppet.features.minitar? && Puppet.features.zlib?) do
-  let(:minitar)    { described_class.new }
-
-  describe "Extracts tars with long and short pathnames" do
-    let (:sourcetar) { File.expand_path('../../../../fixtures/module.tar.gz', __FILE__) }
-
-    let (:longfilepath)  { "puppetlabs-dsc-1.0.0/lib/puppet_x/dsc_resources/xWebAdministration/DSCResources/MSFT_xWebAppPoolDefaults/MSFT_xWebAppPoolDefaults.schema.mof" }
-    let (:shortfilepath) { "puppetlabs-dsc-1.0.0/README.md" }
-
-    it "unpacks a tar with a short path length" do
-      extractdir = PuppetSpec::Files.tmpdir('minitar')
-
-      minitar.unpack(sourcetar,extractdir,'module')
-      expect(File).to exist(File.expand_path("#{extractdir}/#{shortfilepath}"))
-    end
-
-    it "unpacks a tar with a long path length" do
-      extractdir = PuppetSpec::Files.tmpdir('minitar')
-
-      minitar.unpack(sourcetar,extractdir,'module')
-      expect(File).to exist(File.expand_path("#{extractdir}/#{longfilepath}"))
-    end
-  end
+require 'spec_helper'
+require 'puppet/module_tool'
+require 'puppet_spec/files'
+
+describe Puppet::ModuleTool::Tar::Mini, :if => (Puppet.features.minitar? && Puppet.features.zlib?) do
+  let(:minitar)    { described_class.new }
+
+  describe "Extracts tars with long and short pathnames" do
+    let (:sourcetar) { File.expand_path('../../../../fixtures/module.tar.gz', __FILE__) }
+
+    let (:longfilepath)  { "puppetlabs-dsc-1.0.0/lib/puppet_x/dsc_resources/xWebAdministration/DSCResources/MSFT_xWebAppPoolDefaults/MSFT_xWebAppPoolDefaults.schema.mof" }
+    let (:shortfilepath) { "puppetlabs-dsc-1.0.0/README.md" }
+
+    it "unpacks a tar with a short path length" do
+      extractdir = PuppetSpec::Files.tmpdir('minitar')
+
+      minitar.unpack(sourcetar,extractdir,'module')
+      expect(File).to exist(File.expand_path("#{extractdir}/#{shortfilepath}"))
+    end
+
+    it "unpacks a tar with a long path length" do
+      extractdir = PuppetSpec::Files.tmpdir('minitar')
+
+      minitar.unpack(sourcetar,extractdir,'module')
+      expect(File).to exist(File.expand_path("#{extractdir}/#{longfilepath}"))
+    end
+  end
 end

data/spec/integration/parser/catalog_spec.rb

@@ -7,6 +7,18 @@ describe "A catalog" do
   include PuppetSpec::Compiler
 
   context "when compiled" do
+    let(:env) { Puppet::Node::Environment.create(:testing, []) }
+    let(:node) { Puppet::Node.new('test', :environment => env) }
+    let(:loaders) { Puppet::Pops::Loaders.new(env) }
+
+    around :each do |example|
+      Puppet::Parser::Compiler.any_instance.stubs(:loaders).returns(loaders)
+      Puppet.override(:loaders => loaders, :current_environment => env) do
+        example.run
+        Puppet::Pops::Loaders.clear
+      end
+    end
+
     context "when transmitted to the agent" do
 
       it "preserves the order in which the resources are added to the catalog" do
@@ -78,12 +90,12 @@ describe "A catalog" do
   end
 
   def master_catalog_for(manifest)
-    master_catalog = Puppet::Resource::Catalog::Compiler.new.filter(compile_to_catalog(manifest))
+    master_catalog = Puppet::Resource::Catalog::Compiler.new.filter(compile_to_catalog(manifest, node))
   end
 
   def master_and_agent_catalogs_for(manifest)
     compiler = Puppet::Resource::Catalog::Compiler.new
-    master_catalog = compiler.filter(compile_to_catalog(manifest))
+    master_catalog = compiler.filter(compile_to_catalog(manifest, node))
     agent_catalog = Puppet::Resource::Catalog.convert_from(:pson, master_catalog.render(:pson))
     [master_catalog, agent_catalog]
   end

data/spec/integration/parser/compiler_spec.rb

@@ -1048,6 +1048,37 @@ describe Puppet::Parser::Compiler do
       end
     end
 
+    it 'assigns multiple variables from a class' do
+      node = Puppet::Node.new("testnodex")
+      catalog = compile_to_catalog(<<-PP, node)
+      class foo::bar::example($x = 100)  {
+        $a = 10
+        $c = undef
+      }
+      include foo::bar::example
+
+      [$a, $x, $c] = Class['foo::bar::example']
+      notify{'check_me': message => "$a, $x, -${c}-" }
+      PP
+      expect(catalog).to have_resource("Notify[check_me]").with_parameter(:message, "10, 100, --")
+    end
+
+    it 'errors on attempt to assigns multiple variables from a class when variable does not exist' do
+      node = Puppet::Node.new("testnodex")
+      expect do
+        compile_to_catalog(<<-PP, node)
+        class foo::bar::example($x = 100)  {
+          $ah = 10
+          $c = undef
+        }
+        include foo::bar::example
+
+        [$a, $x, $c] = Class['foo::bar::example']
+        notify{'check_me': message => "$a, $x, -${c}-" }
+        PP
+      end.to raise_error(/No value for required variable '\$foo::bar::example::a'/)
+    end
+
     it "should not create duplicate resources when a class is referenced both directly and indirectly by the node classifier (4792)" do
       node = Puppet::Node.new("testnodex")
       node.classes = ['foo', 'bar']
@@ -1243,6 +1274,66 @@ describe Puppet::Parser::Compiler do
       end
     end
 
+    describe "relationships to non existing resources when strict == :error" do
+      before(:each) do
+        Puppet[:strict] = :error
+      end
+
+      [ 'before',
+        'subscribe',
+        'notify',
+        'require'].each do |meta_param|
+        it "are reported as an error when formed via meta parameter #{meta_param}" do
+          expect { 
+            compile_to_catalog(<<-PP)
+              notify{ x : #{meta_param} => Notify[tooth_fairy] }
+            PP
+          }.to raise_error(/Could not find resource 'Notify\[tooth_fairy\]' in parameter '#{meta_param}'/)
+        end
+      end
+    end
+
+    describe "relationships to non existing resources when strict == :warning" do
+      before(:each) do
+        Puppet[:strict] = :warning
+      end
+
+      [ 'before',
+        'subscribe',
+        'notify',
+        'require'].each do |meta_param|
+        it "are reported as a warning when formed via meta parameter #{meta_param}" do
+          expect { 
+            compile_to_catalog(<<-PP)
+              notify{ x : #{meta_param} => Notify[tooth_fairy] }
+            PP
+            expect(@logs).to have_matching_log(/Could not find resource 'Notify\[tooth_fairy\]' in parameter '#{meta_param}'/)
+
+          }.to_not raise_error()
+        end
+      end
+    end
+
+    describe "relationships to non existing resources when strict == :off" do
+      before(:each) do
+        Puppet[:strict] = :off
+      end
+
+      [ 'before',
+        'subscribe',
+        'notify',
+        'require'].each do |meta_param|
+        it "does not log an error for meta parameter #{meta_param}" do
+          expect { 
+            compile_to_catalog(<<-PP)
+              notify{ x : #{meta_param} => Notify[tooth_fairy] }
+            PP
+            expect(@logs).to_not have_matching_log(/Could not find resource 'Notify\[tooth_fairy\]' in parameter '#{meta_param}'/)
+          }.to_not raise_error()
+        end
+      end
+    end
+
     describe "relationships can be formed" do
       def extract_name(ref)
         ref.sub(/File\[(\w+)\]/, '\1')
@@ -1488,10 +1579,10 @@ describe Puppet::Parser::Compiler do
 
       it 'accepts a Resource as a Type' do
         catalog = compile_to_catalog(<<-MANIFEST)
+          define bar($text) { }
           define foo(Type[Bar] $x) {
             notify { 'test': message => $x[text] }
           }
-          define bar($text) { }
           bar { 'joke': text => 'knock knock' }
           foo { 'test': x => Bar[joke] }
         MANIFEST
@@ -1504,7 +1595,7 @@ describe Puppet::Parser::Compiler do
             define foo(Struct[{b => Integer, d=>String}] $a) { }
             foo{ bar: a => {b => 5, c => 'stuff'}}
           MANIFEST
-        end.to raise_error(/Foo\[bar\]:\s+parameter 'a' expects a value for key 'd'\s+parameter 'a' has no 'c' key/m)
+        end.to raise_error(/Foo\[bar\]:\s+parameter 'a' expects a value for key 'd'\s+parameter 'a' unrecognized key 'c'/m)
       end
     end
 
@@ -1574,10 +1665,10 @@ describe Puppet::Parser::Compiler do
 
       it 'accepts a Resource as a Type' do
         catalog = compile_to_catalog(<<-MANIFEST)
+          define bar($text) { }
           class foo(Type[Bar] $x) {
             notify { 'test': message => $x[text] }
           }
-          define bar($text) { }
           bar { 'joke': text => 'knock knock' }
           class { 'foo': x => Bar[joke] }
         MANIFEST