puppet 7.9.0 → 7.10.0

data/spec/unit/environments_spec.rb

@@ -139,6 +139,14 @@ describe Puppet::Environments do
       end
     end
 
+    it "implements guard and unguard" do
+      loader_from(:filesystem => [directory_tree],
+                  :directory => directory_tree.children.first) do |loader|
+        expect(loader.guard('env1')).to be_nil
+        expect(loader.unguard('env1')).to be_nil
+      end
+    end
+
     context "with an environment.conf" do
       let(:envdir) do
         FS::MemoryFile.a_directory(File.expand_path("envdir"), [
@@ -631,7 +639,7 @@ config_version=$vardir/random/scripts
         ])
 
         loader_from(:filesystem => [envdir], :directory => envdir) do |loader|
-         cached = Puppet::Environments::Cached.new(loader)
+          cached = Puppet::Environments::Cached.new(loader)
           cached.get(:env1)
           cached.get(:env2)
           cached.get(:env3)
@@ -642,6 +650,51 @@ config_version=$vardir/random/scripts
         end
       end
 
+      it "normalizes environment name to symbol" do
+        env = Puppet::Node::Environment.create(:cached, [])
+        mocked_loader = double('loader')
+
+        expect(mocked_loader).not_to receive(:get).with('cached')
+        expect(mocked_loader).to receive(:get).with(:cached).and_return(env).once
+        expect(mocked_loader).to receive(:get_conf).with(:cached).and_return(Puppet::Settings::EnvironmentConf.static_for(env, 20)).once
+
+        cached = Puppet::Environments::Cached.new(mocked_loader)
+        cached.get('cached')
+        cached.get(:cached)
+      end
+
+      it "caches environment name as symbol and only once" do
+        mocked_loader = double('loader')
+
+        env = Puppet::Node::Environment.create(:cached, [])
+        allow(mocked_loader).to receive(:get).with(:cached).and_return(env)
+        allow(mocked_loader).to receive(:get_conf).with(:cached).and_return(Puppet::Settings::EnvironmentConf.static_for(env, 20))
+
+        cached = Puppet::Environments::Cached.new(mocked_loader)
+        cached.get(:cached)
+        cached.get('cached')
+
+        expect(cached.instance_variable_get(:@cache).keys).to eq([:cached])
+      end
+
+      it "is able to cache multiple environments" do
+        mocked_loader = double('loader')
+
+        env1 = Puppet::Node::Environment.create(:env1, [])
+        allow(mocked_loader).to receive(:get).with(:env1).and_return(env1)
+        allow(mocked_loader).to receive(:get_conf).with(:env1).and_return(Puppet::Settings::EnvironmentConf.static_for(env1, 20))
+
+        env2 = Puppet::Node::Environment.create(:env2, [])
+        allow(mocked_loader).to receive(:get).with(:env2).and_return(env2)
+        allow(mocked_loader).to receive(:get_conf).with(:env2).and_return(Puppet::Settings::EnvironmentConf.static_for(env2, 20))
+
+        cached = Puppet::Environments::Cached.new(mocked_loader)
+        cached.get('env1')
+        cached.get('env2')
+
+        expect(cached.instance_variable_get(:@cache).keys).to eq([:env1, :env2])
+      end
+
       it "returns nil if env not found" do
         cached_loader_from(:filesystem => [directory_tree], :directory => directory_tree.children.first) do |loader|
           expect(loader.get(:doesnotexist)).to be_nil
@@ -697,6 +750,17 @@ config_version=$vardir/random/scripts
         cached.get_conf(:cached)
       end
 
+      it "normalizes environment name to symbol" do
+        env = Puppet::Node::Environment.create(:cached, [])
+        mocked_loader = double('loader')
+        expect(mocked_loader).to receive(:get_conf).with(:cached).and_return(Puppet::Settings::EnvironmentConf.static_for(env, 20)).twice
+
+        cached = Puppet::Environments::Cached.new(mocked_loader)
+
+        cached.get_conf('cached')
+        cached.get_conf(:cached)
+      end
+
       it "returns nil if environment is not found" do
         cached_loader_from(:filesystem => [directory_tree], :directory => directory_tree.children.first) do |loader|
           expect(loader.get_conf(:doesnotexist)).to be_nil
@@ -786,6 +850,83 @@ config_version=$vardir/random/scripts
 
         expect(service.evicted_envs).to eq([:an_environment])
       end
+
+      context "when guarding an environment" do
+        before :each do
+          Puppet[:environment_timeout] = 0
+        end
+
+        let(:name) { :an_environment }
+
+        def with_guard(cached, name, &block)
+          cached.guard(name)
+          begin
+            yield
+          ensure
+            cached.unguard(name)
+          end
+        end
+
+        it "evicts an expired and unguarded environment" do
+          with_environment_loaded(service) do |cached|
+            cached.get!(name)
+          end
+
+          expect(service.created_envs).to eq([name, name])
+          expect(service.evicted_envs).to eq([name])
+        end
+
+        it "does not evict an expired, but guarded environment" do
+          with_environment_loaded(service) do |cached|
+            with_guard(cached, name) do
+              cached.get!(name) # these shouldn't reload
+              cached.get!(name)
+            end
+          end
+
+          expect(service.created_envs).to eq([name])
+          expect(service.evicted_envs).to eq([])
+        end
+
+        it "does not evict an environment marked for expiration, but is guarded" do
+          Puppet[:environment_timeout] = 'unlimited'
+
+          expect(service).to receive(:expired?).never
+
+          with_environment_loaded(service) do |cached|
+            with_guard(cached, name) do
+              cached.get!(name)
+            end
+          end
+
+          expect(service.created_envs).to eq([name])
+          expect(service.evicted_envs).to eq([])
+        end
+
+        it "evicts an environment that is no longer guarded" do
+          with_environment_loaded(service) do |cached|
+            with_guard(cached, name) {}
+
+            cached.get!(name) # this reloads
+          end
+
+          expect(service.created_envs).to eq([name, name])
+          expect(service.evicted_envs).to eq([name])
+        end
+
+        it "can nest guards" do
+          with_environment_loaded(service) do |cached|
+            with_guard(cached, name) do
+              with_guard(cached, name) do
+                cached.get!(name) # doesn't reload
+              end
+            end
+          end
+
+          expect(service.created_envs).to eq([name])
+          expect(service.evicted_envs).to eq([])
+        end
+      end
     end
 
     context '#clear' do
@@ -798,6 +939,14 @@ config_version=$vardir/random/scripts
 
         expect(service.evicted_envs).to eq([:an_environment])
       end
+
+      it "normalizes environment name to symbol" do
+        with_environment_loaded(service) do |cached|
+          cached.clear('an_environment')
+        end
+
+        expect(service.evicted_envs).to eq([:an_environment])
+      end
     end
 
     context '#clear_all' do

data/spec/unit/file_serving/configuration/parser_spec.rb

@@ -159,6 +159,29 @@ describe Puppet::FileServing::Configuration::Parser do
     end
   end
 
+  describe Puppet::FileServing::Configuration::Parser, " when parsing the scripts mount" do
+    include FSConfigurationParserTesting
+
+    before do
+      @mount = double('scriptsmount', :name => "scripts", :validate => true)
+    end
+
+    it "should create an instance of the Scripts Mount class" do
+      write_config_file "[scripts]\n"
+
+      expect(Puppet::FileServing::Mount::Scripts).to receive(:new).with("scripts").and_return(@mount)
+      @parser.parse
+    end
+
+    it "should warn if a path is set" do
+      write_config_file "[scripts]\npath /some/path\n"
+      expect(Puppet::FileServing::Mount::Scripts).to receive(:new).with("scripts").and_return(@mount)
+
+      expect(Puppet).to receive(:warning)
+      @parser.parse
+    end
+  end
+
   describe Puppet::FileServing::Configuration::Parser, " when parsing the plugins mount" do
     include FSConfigurationParserTesting
 

data/spec/unit/file_serving/configuration_spec.rb

@@ -80,15 +80,16 @@ describe Puppet::FileServing::Configuration do
       expect(config.mounted?("one")).to be_truthy
     end
 
-    it "should add modules, plugins, and tasks mounts even if the file does not exist" do
+    it "should add modules, plugins, scripts, and tasks mounts even if the file does not exist" do
       expect(Puppet::FileSystem).to receive(:exist?).and_return(false) # the file doesn't exist
       config = Puppet::FileServing::Configuration.configuration
       expect(config.mounted?("modules")).to be_truthy
       expect(config.mounted?("plugins")).to be_truthy
+      expect(config.mounted?("scripts")).to be_truthy
       expect(config.mounted?("tasks")).to be_truthy
     end
 
-    it "should allow all access to modules, plugins, and tasks if no fileserver.conf exists" do
+    it "should allow all access to modules, plugins, scripts, and tasks if no fileserver.conf exists" do
       expect(Puppet::FileSystem).to receive(:exist?).and_return(false) # the file doesn't exist
       modules = double('modules')
       allow(Puppet::FileServing::Mount::Modules).to receive(:new).and_return(modules)
@@ -99,10 +100,13 @@ describe Puppet::FileServing::Configuration do
       tasks = double('tasks')
       allow(Puppet::FileServing::Mount::Tasks).to receive(:new).and_return(tasks)
 
+      scripts = double('scripts')
+      allow(Puppet::FileServing::Mount::Scripts).to receive(:new).and_return(scripts)
+
       Puppet::FileServing::Configuration.configuration
     end
 
-    it "should not allow access from all to modules, plugins, and tasks if the fileserver.conf provided some rules" do
+    it "should not allow access from all to modules, plugins, scripts, and tasks if the fileserver.conf provided some rules" do
       expect(Puppet::FileSystem).to receive(:exist?).and_return(false) # the file doesn't exist
 
       modules = double('modules')
@@ -114,15 +118,19 @@ describe Puppet::FileServing::Configuration do
       tasks = double('tasks')
       allow(Puppet::FileServing::Mount::Tasks).to receive(:new).and_return(tasks)
 
+      scripts = double('scripts', :empty? => false)
+      allow(Puppet::FileServing::Mount::Scripts).to receive(:new).and_return(scripts)
+
       Puppet::FileServing::Configuration.configuration
     end
 
-    it "should add modules, plugins, and tasks mounts even if they are not returned by the parser" do
+    it "should add modules, plugins, scripts, and tasks mounts even if they are not returned by the parser" do
       expect(@parser).to receive(:parse).and_return("one" => double("mount"))
       expect(Puppet::FileSystem).to receive(:exist?).and_return(true) # the file doesn't exist
       config = Puppet::FileServing::Configuration.configuration
       expect(config.mounted?("modules")).to be_truthy
       expect(config.mounted?("plugins")).to be_truthy
+      expect(config.mounted?("scripts")).to be_truthy
       expect(config.mounted?("tasks")).to be_truthy
     end
   end

data/spec/unit/file_serving/mount/scripts_spec.rb

@@ -0,0 +1,69 @@
+require 'spec_helper'
+require 'puppet/file_serving/mount/scripts'
+
+describe Puppet::FileServing::Mount::Scripts do
+  before do
+    @mount = Puppet::FileServing::Mount::Scripts.new("scripts")
+
+    @environment = double('environment', :module => nil)
+    @request = double('request', :environment => @environment)
+  end
+
+  describe "when finding files" do
+    it "should fail if no module is specified" do
+      expect { @mount.find("", @request) }.to raise_error(/No module specified/)
+    end
+
+    it "should use the provided environment to find the module" do
+      expect(@environment).to receive(:module)
+
+      @mount.find("foo", @request)
+    end
+
+    it "should treat the first field of the relative path as the module name" do
+      expect(@environment).to receive(:module).with("foo")
+      @mount.find("foo/bar/baz", @request)
+    end
+
+    it "should return nil if the specified module does not exist" do
+      expect(@environment).to receive(:module).with("foo")
+      @mount.find("foo/bar/baz", @request)
+    end
+
+    it "should return the file path from the module" do
+      mod = double('module')
+      expect(mod).to receive(:script).with("bar/baz").and_return("eh")
+      expect(@environment).to receive(:module).with("foo").and_return(mod)
+      expect(@mount.find("foo/bar/baz", @request)).to eq("eh")
+    end
+  end
+
+  describe "when searching for files" do
+    it "should fail if no module is specified" do
+      expect { @mount.search("", @request) }.to raise_error(/No module specified/)
+    end
+
+    it "should use the node's environment to search the module" do
+      expect(@environment).to receive(:module)
+
+      @mount.search("foo", @request)
+    end
+
+    it "should treat the first field of the relative path as the module name" do
+      expect(@environment).to receive(:module).with("foo")
+      @mount.search("foo/bar/baz", @request)
+    end
+
+    it "should return nil if the specified module does not exist" do
+      expect(@environment).to receive(:module).with("foo").and_return(nil)
+      @mount.search("foo/bar/baz", @request)
+    end
+
+    it "should return the script path as an array from the module" do
+      mod = double('module')
+      expect(mod).to receive(:script).with("bar/baz").and_return("eh")
+      expect(@environment).to receive(:module).with("foo").and_return(mod)
+      expect(@mount.search("foo/bar/baz", @request)).to eq(["eh"])
+    end
+  end
+end

data/spec/unit/functions/logging_spec.rb

@@ -6,6 +6,7 @@ describe 'the log function' do
 
   def collect_logs(code)
     Puppet[:code] = code
+    Puppet[:environment_timeout] = 10
     node = Puppet::Node.new('logtest')
     compiler = Puppet::Parser::Compiler.new(node)
     node.environment.check_for_reparse

data/spec/unit/http/service/compiler_spec.rb

@@ -95,6 +95,14 @@ describe Puppet::HTTP::Service::Compiler do
       subject.post_catalog(certname, environment: 'production', facts: facts, configured_environment: 'agent_specified')
     end
 
+    it 'includes check_environment' do
+      stub_request(:post, uri)
+        .with(body: hash_including('check_environment' => 'false'))
+        .to_return(**catalog_response)
+
+      subject.post_catalog(certname, environment: 'production', facts: facts)
+    end
+
     it 'includes transaction_uuid' do
       uuid = "ec3d2844-b236-4287-b0ad-632fbb4d1ff0"
 

data/spec/unit/indirector/catalog/compiler_spec.rb

@@ -11,6 +11,9 @@ def set_facts(fact_hash)
 end
 
 describe Puppet::Resource::Catalog::Compiler do
+  include Matchers::Resource
+  include PuppetSpec::Files
+
   let(:compiler) { described_class.new }
   let(:node_name) { "foo" }
   let(:node) { Puppet::Node.new(node_name)}
@@ -236,6 +239,46 @@ describe Puppet::Resource::Catalog::Compiler do
       expect { compiler.find(@request) }.to raise_error Puppet::Error,
         "Unable to find a common checksum type between agent '' and master '[:sha256, :sha256lite, :md5, :md5lite, :sha1, :sha1lite, :sha512, :sha384, :sha224, :mtime, :ctime, :none]'."
     end
+
+    it "prevents the environment from being evicted during compilation" do
+      Puppet[:environment_timeout] = 0
+
+      envs = Puppet.lookup(:environments)
+
+      expect(compiler).to receive(:compile) do
+        # we should get the same object
+        expect(envs.get!(:production)).to equal(envs.get!(:production))
+      end
+
+      compiler.find(@request)
+    end
+
+    context 'when checking agent and server specified environments' do
+      before :each do
+        FileUtils.mkdir_p(File.join(Puppet[:environmentpath], 'env_server'))
+        FileUtils.mkdir_p(File.join(Puppet[:environmentpath], 'env_agent'))
+
+        node.environment = 'env_server'
+        allow(Puppet::Node.indirection).to receive(:find).and_return(node)
+
+        @request.environment = 'env_agent'
+      end
+
+      it 'ignores mismatched environments by default' do
+        catalog = compiler.find(@request)
+
+        expect(catalog.environment).to eq('env_server')
+        expect(catalog).to have_resource('Stage[main]')
+      end
+
+      it 'returns an empty catalog if asked to check the environment and they are mismatched' do
+        @request.options[:check_environment] = "true"
+        catalog = compiler.find(@request)
+
+        expect(catalog.environment).to eq('env_server')
+        expect(catalog.resources).to be_empty
+      end
+    end
   end
 
   describe "when handling a request with facts" do
@@ -564,6 +607,50 @@ describe Puppet::Resource::Catalog::Compiler do
       metadata
     end
 
+    describe "and the environment is a symlink and versioned_environment_dirs is true" do
+
+      let(:tmpdir) { Dir.mktmpdir }
+
+      before(:each) do
+        Puppet[:versioned_environment_dirs] = true
+        prod_path = File.join(Puppet[:environmentpath], 'production')
+        FileUtils.rm_rf(prod_path)
+        FileUtils.symlink(tmpdir, prod_path)
+      end
+
+      it "inlines metadata for a file" do
+        catalog = compile_to_catalog(<<-MANIFEST, node)
+        file { '#{path}':
+          ensure => file,
+          source => '#{source}'
+        }
+      MANIFEST
+
+        module_relative_path = 'modules/mymodule/files/config_file.txt'
+        metadata = stubs_file_metadata(checksum_type,
+                                       checksum_value,
+                                       module_relative_path,
+                                       File.join(tmpdir, module_relative_path) )
+        expect(metadata).to receive(:source=).with(source)
+        expect(metadata).to receive(:content_uri=).with("puppet:///#{module_relative_path}")
+
+        options = {
+          :environment => catalog.environment_instance,
+          :links => :manage,
+          :checksum_type => checksum_type.to_sym,
+          :source_permissions => :ignore
+        }
+        expect(Puppet::FileServing::Metadata.indirection).to receive(:find).with(source, options).and_return(metadata)
+
+        compiler.send(:inline_metadata, catalog, checksum_type)
+
+
+        expect(catalog.metadata[path]).to eq(metadata)
+        expect(catalog.recursive_metadata).to be_empty
+
+      end
+    end
+
     it "inlines metadata for a file" do
       catalog = compile_to_catalog(<<-MANIFEST, node)
         file { '#{path}':