puppet 6.11.1 → 6.16.0

data/spec/unit/http/session_spec.rb

@@ -10,12 +10,16 @@ describe Puppet::HTTP::Session do
     double('good', url: uri, connect: nil)
   }
   let(:bad_service) {
-    service = double('good', url: uri)
-    allow(service).to receive(:connect).and_raise(Puppet::HTTP::ConnectionError, 'whoops')
-    service
+    create_bad_service
   }
 
-  class DummyResolver
+  def create_bad_service(failure_message = 'whoops')
+    service = double('bad', url: uri)
+    allow(service).to receive(:connect).and_raise(Puppet::HTTP::ConnectionError, failure_message)
+    service
+  end
+
+  class DummyResolver < Puppet::HTTP::Resolver
     attr_reader :count
 
     def initialize(service)
@@ -23,21 +27,19 @@ describe Puppet::HTTP::Session do
       @count = 0
     end
 
-    def resolve(session, name, &block)
+    def resolve(session, name, ssl_context: nil, error_handler: nil)
       @count += 1
-      yield @service
+      return @service if check_connection?(session, @service, ssl_context: ssl_context, error_handler: error_handler)
     end
   end
 
   context 'when routing' do
     it 'returns the first resolved service' do
-      Puppet[:log_level] = :debug
       resolvers = [DummyResolver.new(bad_service), DummyResolver.new(good_service)]
       session = described_class.new(client, resolvers)
       resolved = session.route_to(:ca)
 
       expect(resolved).to eq(good_service)
-      expect(@logs).to include(an_object_having_attributes(level: :debug, message: "Connection to #{uri} failed, trying next route: whoops"))
     end
 
     it 'only resolves once per session' do
@@ -58,6 +60,29 @@ describe Puppet::HTTP::Session do
       }.to raise_error(Puppet::HTTP::RouteError, 'No more routes to ca')
     end
 
+    it 'logs all routing failures as errors when there are no more routes' do
+      resolvers = [DummyResolver.new(create_bad_service('whoops1')), DummyResolver.new(create_bad_service('whoops2'))]
+      session = described_class.new(client, resolvers)
+
+      expect {
+        session.route_to(:ca)
+      }.to raise_error(Puppet::HTTP::RouteError, 'No more routes to ca')
+
+      expect(@logs).to include(an_object_having_attributes(level: :err, message: "whoops1"),
+                               an_object_having_attributes(level: :err, message: "whoops2"))
+    end
+
+    it 'logs routing failures as debug until routing succeeds' do
+      Puppet[:log_level] = 'debug'
+
+      resolvers = [DummyResolver.new(bad_service), DummyResolver.new(good_service)]
+      session = described_class.new(client, resolvers)
+      session.route_to(:ca)
+
+      expect(@logs).to include(an_object_having_attributes(level: :debug, message: "Connection to #{uri} failed, trying next route: whoops"))
+      expect(@logs).to_not include(an_object_having_attributes(level: :err))
+    end
+
     it 'accepts an ssl context to use when connecting' do
       alt_context = Puppet::SSL::SSLContext.new
       expect(good_service).to receive(:connect).with(ssl_context: alt_context)
@@ -73,30 +98,223 @@ describe Puppet::HTTP::Session do
         session.route_to(:westbound)
       }.to raise_error(ArgumentError, "Unknown service westbound")
     end
+
+    it 'routes to the service when given a puppet URL with an explicit host' do
+      allow_any_instance_of(Net::HTTP).to receive(:start)
+
+      session = described_class.new(client, [])
+      url = URI("puppet://example.com:8140/:modules/:module/path/to/file")
+      service = session.route_to(:fileserver, url: url)
+
+      expect(service.url.to_s).to eq("https://example.com:8140/puppet/v3")
+    end
+
+    it 'raises a connection error if we cannot connect' do
+      allow_any_instance_of(Net::HTTP).to receive(:start).and_raise(Net::OpenTimeout)
+
+      session = described_class.new(client, [])
+      url = URI('puppet://example.com:8140/:modules/:module/path/to/file')
+
+      expect {
+        session.route_to(:fileserver, url: url)
+      }.to raise_error(Puppet::HTTP::ConnectionError,
+                       %r{Request to https://example.com:8140/puppet/v3 timed out connect operation after .* seconds})
+    end
+
+    it 'resolves the route when given a generic puppet:/// URL' do
+      resolvers = [DummyResolver.new(good_service)]
+      session = described_class.new(client, resolvers)
+      url = URI('puppet:///:modules/:module/path/to/file')
+      service = session.route_to(:fileserver, url: url)
+
+      expect(service.url).to eq(good_service.url)
+    end
   end
 
-  context 'when creating services' do
-    let(:session) { described_class.new(client, []) }
+  context 'when resolving using multiple resolvers' do
+    let(:session) { client.create_session }
+
+    it "prefers SRV records" do
+      Puppet[:use_srv_records] = true
+      Puppet[:server_list] = 'foo.example.com,bar.example.com,baz.example.com'
+      Puppet[:ca_server] = 'caserver.example.com'
+
+      allow_any_instance_of(Puppet::Network::Resolver).to receive(:each_srv_record).and_yield('mars.example.srv', 8140)
+      service = session.route_to(:ca)
+
+      expect(service.url).to eq(URI("https://mars.example.srv:8140/puppet-ca/v1"))
+    end
+
+    it "next prefers :ca_server when explicitly set" do
+      Puppet[:use_srv_records] = true
+      Puppet[:server_list] = 'foo.example.com,bar.example.com,baz.example.com'
+      Puppet[:ca_server] = 'caserver.example.com'
+
+      service = session.route_to(:ca)
+
+      expect(service.url).to eq(URI("https://caserver.example.com:8140/puppet-ca/v1"))
+    end
+
+    it "next prefers the first successful connection from server_list" do
+      Puppet[:use_srv_records] = true
+      Puppet[:server_list] = 'foo.example.com,bar.example.com,baz.example.com'
+
+      allow_any_instance_of(Puppet::Network::Resolver).to receive(:each_srv_record)
+      stub_request(:get, "https://foo.example.com:8140/status/v1/simple/master").to_return(status: 500)
+      stub_request(:get, "https://bar.example.com:8140/status/v1/simple/master").to_return(status: 200)
+
+      service = session.route_to(:ca)
+
+      expect(service.url).to eq(URI("https://bar.example.com:8140/puppet-ca/v1"))
+    end
+
+    it "fails if server_list doesn't return anything valid" do
+      Puppet[:server_list] = 'foo.example.com,bar.example.com'
+
+      allow_any_instance_of(Puppet::Network::Resolver).to receive(:each_srv_record)
+      stub_request(:get, "https://foo.example.com:8140/status/v1/simple/master").to_return(status: 500)
+      stub_request(:get, "https://bar.example.com:8140/status/v1/simple/master").to_return(status: 500)
+
+      expect {
+        session.route_to(:ca)
+      }.to raise_error(Puppet::Error, "Could not select a functional puppet master from server_list: 'foo.example.com,bar.example.com'")
+    end
+
+    it "raises when there are no more routes" do
+      allow_any_instance_of(Net::HTTP).to receive(:start).and_raise(Errno::EHOSTUNREACH)
+      session = client.create_session
+
+      expect {
+        session.route_to(:ca)
+      }.to raise_error(Puppet::HTTP::RouteError, 'No more routes to ca')
+    end
+
+    Puppet::HTTP::Service::SERVICE_NAMES.each do |name|
+      it "resolves #{name} using server_list" do
+        Puppet[:server_list] = 'apple.example.com'
+        req = stub_request(:get, "https://apple.example.com:8140/status/v1/simple/master").to_return(status: 200)
+
+        session.route_to(name)
+
+        expect(req).to have_been_requested
+      end
+    end
 
-    it 'defaults the server and port based on settings' do
-      Puppet[:ca_server] = 'ca.example.com'
-      Puppet[:ca_port] = 8141
-      service = session.create_service(:ca)
+    it 'does not use server_list to resolve the ca service when ca_server is explicitly set' do
+      Puppet[:ca_server] = 'banana.example.com'
 
-      expect(service.url.to_s).to eq("https://ca.example.com:8141/puppet-ca/v1")
+      expect(session.route_to(:ca).url.to_s).to eq("https://banana.example.com:8140/puppet-ca/v1")
     end
 
-    it 'accepts server and port arguments' do
-      service = session.create_service(:ca, 'ca2.example.com', 8142)
+    it 'does not use server_list to resolve the report service when the report_server is explicitly set' do
+      Puppet[:report_server] = 'cherry.example.com'
 
-      expect(service.url.to_s).to eq("https://ca2.example.com:8142/puppet-ca/v1")
+      expect(session.route_to(:report).url.to_s).to eq("https://cherry.example.com:8140/puppet/v3")
+    end
+
+    it 'resolves once for all services in a session' do
+      Puppet[:server_list] = 'apple.example.com'
+      req = stub_request(:get, "https://apple.example.com:8140/status/v1/simple/master").to_return(status: 200)
+
+      Puppet::HTTP::Service::SERVICE_NAMES.each do |name|
+        session.route_to(name)
+      end
+
+      expect(req).to have_been_requested
+    end
+
+    it 'resolves server_list for each new session' do
+      Puppet[:server_list] = 'apple.example.com'
+      req = stub_request(:get, "https://apple.example.com:8140/status/v1/simple/master").to_return(status: 200)
+
+      client.create_session.route_to(:puppet)
+      client.create_session.route_to(:puppet)
+
+      expect(req).to have_been_requested.twice
+    end
+  end
+
+  context 'when retrieving capabilities' do
+    let(:session) do
+      resolver = DummyResolver.new(good_service)
+      described_class.new(client, [resolver])
     end
 
     it 'raises for unknown service names' do
       expect {
         session = described_class.new(client, [])
-        session.create_service(:westbound)
+        session.supports?(:westbound, 'a capability')
       }.to raise_error(ArgumentError, "Unknown service westbound")
     end
+
+    context 'locales' do
+      it 'does not support locales if the cached service has not been resolved' do
+        session = described_class.new(client, [])
+
+        expect(session).to_not be_supports(:puppet, 'locales')
+      end
+
+      it "supports locales if the cached service's version is 5.3.4 or greater" do
+        response = Puppet::HTTP::Response.new({'X-Puppet-Version' => '5.3.4'}, uri)
+
+        session.route_to(:puppet)
+        session.process_response(response)
+
+        expect(session).to be_supports(:puppet, 'locales')
+      end
+
+      it "does not support locales if the cached service's version is 5.3.3" do
+        response = Puppet::HTTP::Response.new({'X-Puppet-Version' => '5.3.3'}, uri)
+
+        session.route_to(:puppet)
+        session.process_response(response)
+
+        expect(session).to_not be_supports(:puppet, 'locales')
+      end
+
+      it "does not support locales if the cached service's version is missing" do
+        response = Puppet::HTTP::Response.new({}, uri)
+
+        session.route_to(:puppet)
+        session.process_response(response)
+
+        expect(session).to_not be_supports(:puppet, 'locales')
+      end
+    end
+
+    context 'json' do
+      it 'does not support json if the cached service has not been resolved' do
+        session = described_class.new(client, [])
+
+        expect(session).to_not be_supports(:puppet, 'json')
+      end
+
+      it "supports json if the cached service's version is 5 or greater" do
+        response = Puppet::HTTP::Response.new({'X-Puppet-Version' => '5.5.12'}, uri)
+
+        session.route_to(:puppet)
+        session.process_response(response)
+
+        expect(session).to be_supports(:puppet, 'json')
+      end
+
+      it "does not support json if the cached service's version is less than 5.0" do
+        response = Puppet::HTTP::Response.new({'X-Puppet-Version' => '4.10.1'}, uri)
+
+        session.route_to(:puppet)
+        session.process_response(response)
+
+        expect(session).to_not be_supports(:puppet, 'json')
+      end
+
+      it "supports json if the cached service's version is missing" do
+        response = Puppet::HTTP::Response.new({}, uri)
+
+        session.route_to(:puppet)
+        session.process_response(response)
+
+        expect(session).to be_supports(:puppet, 'json')
+      end
+    end
   end
 end

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

@@ -15,22 +15,9 @@ describe Puppet::Resource::Catalog::Compiler do
   let(:node_name) { "foo" }
   let(:node) { Puppet::Node.new(node_name)}
 
-  before do
-    allow(Facter).to receive(:to_hash).and_return({})
-  end
-
   describe "when initializing" do
     before do
-      expect(Puppet).to receive(:version).and_return(1)
-      set_facts({
-        'fqdn'       => "my.server.com",
-        'ipaddress'  => "my.ip.address",
-        'ipaddress6' => nil
-        })
-    end
-
-    it "should gather data about itself" do
-      Puppet::Resource::Catalog::Compiler.new
+      allow(Puppet).to receive(:version).and_return(1)
     end
 
     it "should cache the server metadata and reuse it" do
@@ -47,8 +34,6 @@ describe Puppet::Resource::Catalog::Compiler do
 
   describe "when finding catalogs" do
     before do
-      allow(Facter).to receive(:value).and_return("whatever")
-
       allow(node).to receive(:merge)
       allow(Puppet::Node.indirection).to receive(:find).and_return(node)
       @request = Puppet::Indirector::Request.new(:catalog, :find, node_name, nil, :node => node_name)
@@ -255,10 +240,10 @@ describe Puppet::Resource::Catalog::Compiler do
 
   describe "when handling a request with facts" do
     before do
-      Puppet::Node::Facts.indirection.terminus_class = :memory
       allow(Facter).to receive(:value).and_return("something")
 
-      @facts = Puppet::Node::Facts.new('hostname', "fact" => "value", "architecture" => "i386")
+      facts = Puppet::Node::Facts.new('hostname', "fact" => "value", "architecture" => "i386")
+      Puppet::Node::Facts.indirection.save(facts)
     end
 
     def a_legacy_request_that_contains(facts, format = :pson)
@@ -276,6 +261,8 @@ describe Puppet::Resource::Catalog::Compiler do
     end
 
     context "when extracting facts from the request" do
+      let(:facts) { Puppet::Node::Facts.new("hostname") }
+
       it "should do nothing if no facts are provided" do
         request = Puppet::Indirector::Request.new(:catalog, :find, "hostname", nil)
         request.options[:facts] = nil
@@ -285,21 +272,21 @@ describe Puppet::Resource::Catalog::Compiler do
 
       it "should deserialize the facts without changing the timestamp" do
         time = Time.now
-        @facts.timestamp = time
-        request = a_request_that_contains(@facts)
+        facts.timestamp = time
+        request = a_request_that_contains(facts)
         facts = compiler.extract_facts_from_request(request)
         expect(facts.timestamp).to eq(time)
       end
 
       it "accepts PSON facts from older agents" do
-        request = a_legacy_request_that_contains(@facts)
+        request = a_legacy_request_that_contains(facts)
 
         facts = compiler.extract_facts_from_request(request)
-        expect(facts).to eq(@facts)
+        expect(facts).to eq(facts)
       end
 
       it "rejects YAML facts" do
-        request = a_legacy_request_that_contains(@facts, :yaml)
+        request = a_legacy_request_that_contains(facts, :yaml)
 
         expect {
           compiler.extract_facts_from_request(request)
@@ -307,7 +294,7 @@ describe Puppet::Resource::Catalog::Compiler do
       end
 
       it "rejects unknown fact formats" do
-        request = a_request_that_contains(@facts)
+        request = a_request_that_contains(facts)
         request.options[:facts_format] = 'unknown-format'
 
         expect {
@@ -317,15 +304,17 @@ describe Puppet::Resource::Catalog::Compiler do
     end
 
     context "when saving facts from the request" do
+      let(:facts) { Puppet::Node::Facts.new("hostname") }
+
       it "should save facts if they were issued by the request" do
-        request = a_request_that_contains(@facts)
+        request = a_request_that_contains(facts)
 
         options = {
           :environment => request.environment,
           :transaction_uuid => request.options[:transaction_uuid],
         }
 
-        expect(Puppet::Node::Facts.indirection).to receive(:save).with(@facts, nil, options)
+        expect(Puppet::Node::Facts.indirection).to receive(:save).with(facts, nil, options)
         compiler.find(request)
       end
 
@@ -337,7 +326,7 @@ describe Puppet::Resource::Catalog::Compiler do
           :transaction_uuid => request.options[:transaction_uuid],
         }
 
-        expect(Puppet::Node::Facts.indirection).not_to receive(:save).with(@facts, nil, options)
+        expect(Puppet::Node::Facts.indirection).not_to receive(:save).with(facts, nil, options)
         compiler.find(request)
       end
     end
@@ -345,7 +334,6 @@ describe Puppet::Resource::Catalog::Compiler do
 
   describe "when finding nodes" do
     it "should look node information up via the Node class with the provided key" do
-      allow(Facter).to receive(:value).and_return("whatever")
       request = Puppet::Indirector::Request.new(:catalog, :find, node_name, nil)
       allow(compiler).to receive(:compile)
 
@@ -471,9 +459,39 @@ describe Puppet::Resource::Catalog::Compiler do
     end
   end
 
+  describe "after finding nodes when checking for a PE version" do
+    include PuppetSpec::Compiler
+
+    let(:pe_version_file) { '/opt/puppetlabs/server/pe_version' }
+    let(:request) { Puppet::Indirector::Request.new(:catalog, :find, node_name, nil) }
+
+    before :each do
+      Puppet[:code] = 'notify { "PE Version: $pe_serverversion": }'
+    end
+
+    it "should not add 'pe_serverversion' when FOSS" do
+      allow(Puppet::Node.indirection).to receive(:find).with(node_name, anything).and_return(node)
+      catalog = compiler.find(request)
+
+      expect(catalog.resource('notify', 'PE Version: 2019.2.0')).to be_nil
+    end
+
+    it "should add 'pe_serverversion' when PE" do
+      allow(File).to receive(:readable?).and_call_original
+      allow(File).to receive(:readable?).with(pe_version_file).and_return(true)
+      allow(File).to receive(:zero?).with(pe_version_file).and_return(false)
+      allow(File).to receive(:read).and_call_original
+      allow(File).to receive(:read).with(pe_version_file).and_return('2019.2.0')
+
+      allow(Puppet::Node.indirection).to receive(:find).with(node_name, anything).and_return(node)
+      catalog = compiler.find(request)
+
+      expect(catalog.resource('notify', 'PE Version: 2019.2.0')).to be
+    end
+  end
+
   describe "when filtering resources" do
     before :each do
-      allow(Facter).to receive(:value)
       @catalog = double('catalog')
       allow(@catalog).to receive(:respond_to?).with(:filter).and_return(true)
     end