puppet 6.18.0-x86-mingw32 → 6.19.0-x86-mingw32

data/spec/unit/environments_spec.rb

@@ -436,25 +436,6 @@ config_version=$vardir/random/scripts
           end
         end
       end
-
-      context "custom cache expiration service" do
-        it "consults the custom service to expire the cache" do
-          loader_from(:filesystem => [directory_tree],
-                      :directory => directory_tree.children.first) do |loader|
-            service = ReplayExpirationService.new([true])
-            using_expiration_service(service) do
-
-              cached = Puppet::Environments::Cached.new(loader)
-              cached.get(:an_environment)
-              cached.get(:an_environment)
-
-              expect(service.created_envs).to include(:an_environment)
-              expect(service.expired_envs).to include(:an_environment)
-              expect(service.evicted_envs).to include(:an_environment)
-            end
-          end
-        end
-      end
     end
   end
 
@@ -645,6 +626,102 @@ config_version=$vardir/random/scripts
       end
     end
 
+    context "expiration policies" do
+      let(:service) { ReplayExpirationService.new }
+
+      # The environment named `:an_environment` will already be loaded when the
+      # block is yielded to
+      def with_environment_loaded(service, &block)
+        loader_from(:filesystem => [directory_tree], :directory => directory_tree.children.first) do |loader|
+          using_expiration_service(service) do
+            cached = Puppet::Environments::Cached.new(loader)
+            cached.get!(:an_environment)
+
+            yield cached if block_given?
+          end
+        end
+      end
+
+      it "notifies when the environment is first created" do
+        with_environment_loaded(service)
+
+        expect(service.created_envs).to eq([:an_environment])
+      end
+
+      it "does not evict an unexpired environment" do
+        Puppet[:environment_timeout] = 'unlimited'
+
+        with_environment_loaded(service) do |cached|
+          cached.get!(:an_environment)
+        end
+
+        expect(service.created_envs).to eq([:an_environment])
+        expect(service.evicted_envs).to eq([])
+      end
+
+      it "evicts an expired environment" do
+        service = ReplayExpirationService.new
+
+        # The `Cached#clear_all_expired` method tries to optimize the case where
+        # no entries are expired. But if `Time.now < @next_expiration` and there is
+        # an expired entry, then the `service#expired?` method is called twice.
+        expect(service).to receive(:expired?).twice.and_return(true)
+
+        with_environment_loaded(service) do |cached|
+          cached.get!(:an_environment)
+        end
+
+        expect(service.created_envs).to eq([:an_environment, :an_environment])
+        expect(service.evicted_envs).to eq([:an_environment])
+      end
+
+      it "evicts an environment that hasn't been recently touched" do
+        Puppet[:environment_timeout] = 1
+        Puppet[:environment_timeout_mode] = :from_last_used
+
+        with_environment_loaded(service) do |cached|
+          future = Time.now + 60
+          expect(Time).to receive(:now).and_return(future).at_least(:once)
+
+          # this should cause the cached environment to be evicted and a new one created
+          cached.get!(:an_environment)
+        end
+
+        expect(service.created_envs).to eq([:an_environment, :an_environment])
+        expect(service.evicted_envs).to eq([:an_environment])
+
+      end
+
+      it "reuses an environment that was recently touched" do
+        Puppet[:environment_timeout] = 60
+        Puppet[:environment_timeout_mode] = :from_last_used
+
+        with_environment_loaded(service) do |cached|
+          # reuse the already cached environment
+          cached.get!(:an_environment)
+        end
+
+        expect(service.created_envs).to eq([:an_environment])
+        expect(service.evicted_envs).to eq([])
+      end
+
+      it "evicts a recently touched environment" do
+        Puppet[:environment_timeout] = 60
+        Puppet[:environment_timeout_mode] = :from_last_used
+
+        # see note above about "twice"
+        expect(service).to receive(:expired?).twice.and_return(true)
+
+        with_environment_loaded(service) do |cached|
+          # even though the environment was recently touched, it's been expired
+          cached.get!(:an_environment)
+        end
+
+        expect(service.created_envs).to eq([:an_environment, :an_environment])
+        expect(service.evicted_envs).to eq([:an_environment])
+      end
+    end
+
     it "gets an environment.conf" do
       loader_from(:filesystem => [directory_tree], :directory => directory_tree.children.first) do |loader|
         expect(Puppet::Environments::Cached.new(loader).get_conf(:an_environment)).to match_environment_conf(:an_environment).
@@ -746,31 +823,21 @@ config_version=$vardir/random/scripts
     end
   end
 
-  class ReplayExpirationService
-    attr_reader :created_envs, :expired_envs, :evicted_envs
+  class ReplayExpirationService < Puppet::Environments::Cached::DefaultCacheExpirationService
+    attr_reader :created_envs, :evicted_envs
 
-    def initialize(expiration_sequence)
+    def initialize
       @created_envs = []
-      @expired_envs = []
       @evicted_envs = []
-      @expiration_sequence = expiration_sequence
     end
 
     def created(env)
       @created_envs << env.name
     end
 
-    def expired?(env_name)
-      # make expired? idempotent
-      return true if @expired_envs.include? (env_name)
-      @expired_envs << env_name
-      @expiration_sequence.pop
-    end
-
     def evicted(env_name)
       @evicted_envs << env_name
     end
   end
-
 end
 end

data/spec/unit/face/config_spec.rb

@@ -200,6 +200,44 @@ trace = true
       expect(Puppet::FileSystem).to receive(:open).with(path, nil, 'r+:UTF-8')
       subject.set('foo', 'bar')
     end
+
+    it "sets settings into the [server] section when setting [master] section settings" do
+      initial_contents = <<-CONFIG
+[master]
+setting = old_setting_value
+untouched_setting = value
+      CONFIG
+
+      myinitialfile = StringIO.new(initial_contents)
+      allow(Puppet::FileSystem).to receive(:open).with(path, anything, anything).and_yield(myinitialfile)
+
+      expect {
+        subject.set('setting', 'new_setting_value', {:section => 'master'})
+      }.to output("Deleted setting from 'master': 'setting = old_setting_value', and adding it to 'server' section\n").to_stdout
+      modified_content = <<-CONFIG
+[master]
+untouched_setting = value
+[server]
+setting = new_setting_value
+      CONFIG
+
+      mymodifiedfile = StringIO.new(modified_content)
+      expect(myinitialfile.string).to match(mymodifiedfile.string)
+    end
+
+    it "setting [master] section settings, sets settings into [server] section instead" do
+      myinitialfile = StringIO.new("")
+      allow(Puppet::FileSystem).to receive(:open).with(path, anything, anything).and_yield(myinitialfile)
+      subject.set('setting_name', 'value', {:section => 'master'})
+
+      expected_content = <<-CONFIG
+[server]
+setting_name = value
+      CONFIG
+
+      myexpectedfile = StringIO.new(expected_content)
+      expect(myinitialfile.string).to match(myexpectedfile.string)
+    end
   end
 
   context 'when the puppet.conf file does not exist' do
@@ -249,6 +287,24 @@ trace = true
       expect(Puppet).to receive(:warning).with("No setting found in configuration file for section 'main' setting name 'setting'")
       subject.delete('setting', {:section => 'main'})
     end
+
+    ['master', 'server'].each do |section|
+      describe "when deleting from [#{section}] section" do
+        it "deletes section values from both [server] and [master] sections" do
+          allow(Puppet::FileSystem).to receive(:open).with(path, anything, anything).and_yield(StringIO.new)
+          config = Puppet::Settings::IniFile.new([Puppet::Settings::IniFile::DefaultSection.new])
+          manipulator = Puppet::Settings::IniFile::Manipulator.new(config)
+          allow(Puppet::Settings::IniFile::Manipulator).to receive(:new).and_return(manipulator)
+
+          expect(manipulator).to receive(:delete).with('master', 'setting').and_return('setting=value')
+          expect(manipulator).to receive(:delete).with('server', 'setting').and_return('setting=value')
+          expect {
+            subject.delete('setting', {:section => section})
+          }.to output(/Deleted setting from 'master': 'setting'\nDeleted setting from 'server': 'setting'\n/).to_stdout
+        end
+      end
+    end
+
   end
 
   shared_examples_for :config_printing_a_section do |section|

data/spec/unit/face/node_spec.rb

@@ -74,9 +74,9 @@ describe Puppet::Face[:node, '0.0.1'] do
           subject.clean('hostname')
         end
 
-        it "should run in master mode" do
+        it "should run in server mode" do
           subject.clean('hostname')
-          expect(Puppet.run_mode).to be_master
+          expect(Puppet.run_mode).to be_server
         end
 
         it "should set node cache as yaml" do

data/spec/unit/file_system_spec.rb

@@ -872,8 +872,7 @@ describe "Puppet::FileSystem" do
 
             # regardless of slash direction, return value is drive letter
             expanded = Puppet::FileSystem.expand_path(slash)
-            expect(expanded).to eq(ENV['SystemDrive'] + File::SEPARATOR)
-            expect(expanded).to eq(File.expand_path(slash))
+            expect(expanded).to match(/^[a-z]:/i)
           end
         end
 

data/spec/unit/http/resolver_spec.rb

@@ -43,9 +43,25 @@ describe Puppet::HTTP::Resolver do
       expect(service.url.to_s).to eq("https://ca.example.com:8141/puppet-ca/v1")
     end
 
-    it 'logs unsuccessful HTTP 500 responses' do
-      Puppet[:log_level] = "debug"
+    it 'includes extra http headers' do
+      Puppet[:http_extra_headers] = 'region:us-west'
+
+      stub_request(:get, "https://ca.example.com:8141/status/v1/simple/master")
+        .with(headers: {'Region' => 'us-west'})
+
+      subject.resolve(session, :ca)
+    end
+
+    it 'uses the provided ssl context during resolution' do
+      stub_request(:get, "https://ca.example.com:8141/status/v1/simple/master").to_return(status: 200)
+
+      other_ctx = Puppet::SSL::SSLContext.new
+      expect(client).to receive(:connect).with(URI("https://ca.example.com:8141/status/v1/simple/master"), options: {ssl_context: other_ctx}).and_call_original
+
+      subject.resolve(session, :ca, ssl_context: other_ctx)
+    end
 
+    it 'logs unsuccessful HTTP 500 responses' do
       stub_request(:get, "https://ca.example.com:8141/status/v1/simple/master").to_return(status: [500, 'Internal Server Error'])
       stub_request(:get, "https://apple.example.com:8142/status/v1/simple/master").to_return(status: 200)
 
@@ -54,11 +70,15 @@ describe Puppet::HTTP::Resolver do
       expect(@logs.map(&:message)).to include(/Puppet server ca.example.com:8141 is unavailable: 500 Internal Server Error/)
     end
 
-    it 'fails if no servers in server_list are accessible' do
+    it 'cancels resolution if no servers in server_list are accessible' do
       stub_request(:get, "https://ca.example.com:8141/status/v1/simple/master").to_return(status: 503)
       stub_request(:get, "https://apple.example.com:8142/status/v1/simple/master").to_return(status: 503)
 
-      expect { subject.resolve(session, :ca) }.to raise_error(Puppet::Error, /^Could not select a functional puppet master from server_list:/)
+      canceled = false
+      canceled_handler = lambda { |cancel| canceled = cancel }
+
+      expect(subject.resolve(session, :ca, canceled_handler: canceled_handler)).to eq(nil)
+      expect(canceled).to eq(true)
     end
 
     it 'cycles through server_list until a valid server is found' do

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

@@ -38,11 +38,11 @@ describe Puppet::HTTP::Service::Ca do
       subject.get_certificate('ca')
     end
 
-    it 'fallbacks to server and masterport' do
+    it 'fallbacks to server and serverport' do
       Puppet[:ca_server] = nil
       Puppet[:ca_port] = nil
       Puppet[:server] = 'ca2.example.com'
-      Puppet[:masterport] = 8142
+      Puppet[:serverport] = 8142
 
       stub_request(:get, "https://ca2.example.com:8142/puppet-ca/v1/certificate/ca").to_return(body: pem)
 

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

@@ -16,7 +16,7 @@ describe Puppet::HTTP::Service::Compiler do
 
   before :each do
     Puppet[:server] = 'compiler.example.com'
-    Puppet[:masterport] = 8140
+    Puppet[:serverport] = 8140
 
     Puppet::Node::Facts.indirection.terminus_class = :memory
   end
@@ -37,7 +37,7 @@ describe Puppet::HTTP::Service::Compiler do
   context 'when routing to the compiler service' do
     it 'defaults the server and port based on settings' do
       Puppet[:server] = 'compiler2.example.com'
-      Puppet[:masterport] = 8141
+      Puppet[:serverport] = 8141
 
       stub_request(:post, "https://compiler2.example.com:8141/puppet/v3/catalog/ziggy?environment=testing")
         .to_return(body: formatter.render(catalog), headers: {'Content-Type' => formatter.mime })

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

@@ -12,7 +12,7 @@ describe Puppet::HTTP::Service::FileServer do
 
   before :each do
     Puppet[:server] = 'www.example.com'
-    Puppet[:masterport] = 443
+    Puppet[:serverport] = 443
   end
 
   context 'when making requests' do
@@ -31,7 +31,7 @@ describe Puppet::HTTP::Service::FileServer do
   context 'when routing to the file service' do
     it 'defaults the server and port based on settings' do
       Puppet[:server] = 'file.example.com'
-      Puppet[:masterport] = 8141
+      Puppet[:serverport] = 8141
 
       stub_request(:get, "https://file.example.com:8141/puppet/v3/file_content/:mount/:path?environment=testing")
 

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

@@ -0,0 +1,82 @@
+require 'spec_helper'
+require 'puppet/http'
+
+describe Puppet::HTTP::Service::Puppetserver do
+  let(:ssl_context) { Puppet::SSL::SSLContext.new }
+  let(:client) { Puppet::HTTP::Client.new(ssl_context: ssl_context) }
+  let(:subject) { client.create_session.route_to(:puppetserver) }
+
+  before :each do
+    Puppet[:server] = 'puppetserver.example.com'
+  end
+
+  context 'when making requests' do
+    it 'includes default HTTP headers' do
+      stub_request(:get, "https://puppetserver.example.com:8140/status/v1/simple/master").with do |request|
+        expect(request.headers).to include({'X-Puppet-Version' => /./, 'User-Agent' => /./})
+        expect(request.headers).to_not include('X-Puppet-Profiling')
+      end.to_return(body: "running", headers: {'Content-Type' => 'text/plain;charset=utf-8'})
+
+      subject.get_simple_status
+    end
+
+    it 'includes extra headers' do
+      Puppet[:http_extra_headers] = 'region:us-west'
+
+      stub_request(:get, "https://puppetserver.example.com:8140/status/v1/simple/master")
+        .with(headers: {'Region' => 'us-west'})
+        .to_return(body: "running", headers: {'Content-Type' => 'text/plain;charset=utf-8'})
+
+      subject.get_simple_status
+    end
+  end
+
+  context 'when routing to the puppetserver service' do
+    it 'defaults the server and port based on settings' do
+      Puppet[:server] = 'compiler2.example.com'
+      Puppet[:serverport] = 8141
+
+      stub_request(:get, "https://compiler2.example.com:8141/status/v1/simple/master")
+        .to_return(body: "running", headers: {'Content-Type' => 'text/plain;charset=utf-8'})
+
+      subject.get_simple_status
+    end
+  end
+
+  context 'when getting puppetserver status' do
+    let(:url) { "https://puppetserver.example.com:8140/status/v1/simple/master" }
+
+    it 'returns the request response and status' do
+      stub_request(:get, url)
+        .to_return(body: "running", headers: {'Content-Type' => 'text/plain;charset=utf-8'})
+
+      resp, status = subject.get_simple_status
+      expect(resp).to be_a(Puppet::HTTP::Response)
+      expect(status).to eq('running')
+    end
+
+    it 'raises a response error if unsuccessful' do
+      stub_request(:get, url).to_return(status: [500, 'Internal Server Error'])
+
+      expect {
+        subject.get_simple_status
+      }.to raise_error do |err|
+        expect(err).to be_an_instance_of(Puppet::HTTP::ResponseError)
+        expect(err.message).to eq("Internal Server Error")
+        expect(err.response.code).to eq(500)
+      end
+    end
+
+    it 'accepts an ssl context' do
+      stub_request(:get, url)
+        .to_return(body: "running", headers: {'Content-Type' => 'text/plain;charset=utf-8'})
+
+      other_ctx = Puppet::SSL::SSLContext.new
+      expect(client).to receive(:connect).with(URI(url), options: {ssl_context: other_ctx}).and_call_original
+
+      session = client.create_session
+      service = Puppet::HTTP::Service.create_service(client, session, :puppetserver, 'puppetserver.example.com', 8140)
+      service.get_simple_status(ssl_context: other_ctx)
+    end
+  end
+end

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

@@ -36,11 +36,11 @@ describe Puppet::HTTP::Service::Report do
       subject.put_report('report', report, environment: environment)
     end
 
-    it 'fallbacks to server and masterport' do
+    it 'fallbacks to server and serverport' do
       Puppet[:report_server] = nil
       Puppet[:report_port] = nil
       Puppet[:server] = 'report2.example.com'
-      Puppet[:masterport] = 8142
+      Puppet[:serverport] = 8142
 
       stub_request(:put, "https://report2.example.com:8142/puppet/v3/report/report?environment=testing")