puppet 6.12.0 → 6.17.0

data/spec/unit/http/session_spec.rb

@@ -10,10 +10,14 @@ describe Puppet::HTTP::Session do
     double('good', url: uri, connect: nil)
   }
   let(:bad_service) {
+    create_bad_service
+  }
+
+  def create_bad_service(failure_message = 'whoops')
     service = double('bad', url: uri)
-    allow(service).to receive(:connect).and_raise(Puppet::HTTP::ConnectionError, 'whoops')
+    allow(service).to receive(:connect).and_raise(Puppet::HTTP::ConnectionError, failure_message)
     service
-  }
+  end
 
   class DummyResolver < Puppet::HTTP::Resolver
     attr_reader :count
@@ -23,21 +27,19 @@ describe Puppet::HTTP::Session do
       @count = 0
     end
 
-    def resolve(session, name, ssl_context: nil)
+    def resolve(session, name, ssl_context: nil, error_handler: nil)
       @count += 1
-      return @service if check_connection?(session, @service, ssl_context: ssl_context)
+      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,6 +98,37 @@ 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 resolving using multiple resolvers' do
@@ -124,7 +180,6 @@ describe Puppet::HTTP::Session do
       }.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
@@ -133,5 +188,133 @@ describe Puppet::HTTP::Session do
         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 'does not use server_list to resolve the ca service when ca_server is explicitly set' do
+      Puppet[:ca_server] = 'banana.example.com'
+
+      expect(session.route_to(:ca).url.to_s).to eq("https://banana.example.com:8140/puppet-ca/v1")
+    end
+
+    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(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.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

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

@@ -3,7 +3,64 @@ require 'spec_helper'
 require 'puppet/indirector/catalog/rest'
 
 describe Puppet::Resource::Catalog::Rest do
-  it "should be a sublcass of Puppet::Indirector::REST" do
-    expect(Puppet::Resource::Catalog::Rest.superclass).to equal(Puppet::Indirector::REST)
+  let(:certname) { 'ziggy' }
+  let(:uri) { %r{/puppet/v3/catalog/ziggy} }
+  let(:formatter) { Puppet::Network::FormatHandler.format(:json) }
+  let(:catalog) { Puppet::Resource::Catalog.new(certname) }
+
+  before :each do
+    Puppet[:server] = 'compiler.example.com'
+    Puppet[:masterport] = 8140
+
+    described_class.indirection.terminus_class = :rest
+  end
+
+  def catalog_response(catalog)
+    { body: formatter.render(catalog), headers: {'Content-Type' => formatter.mime } }
+  end
+
+  it 'finds a catalog' do
+    stub_request(:post, uri).to_return(**catalog_response(catalog))
+
+    expect(described_class.indirection.find(certname)).to be_a(Puppet::Resource::Catalog)
+  end
+
+  it "serializes the environment" do
+    stub_request(:post, uri)
+      .with(query: hash_including('environment' => 'outerspace'))
+      .to_return(**catalog_response(catalog))
+
+    described_class.indirection.find(certname, environment: Puppet::Node::Environment.remote('outerspace'))
+  end
+
+  it 'constructs a catalog environment_instance' do
+    env = Puppet::Node::Environment.remote('outerspace')
+    catalog = Puppet::Resource::Catalog.new(certname, env)
+
+    stub_request(:post, uri).to_return(**catalog_response(catalog))
+
+    expect(described_class.indirection.find(certname).environment_instance).to eq(env)
+  end
+
+  it 'returns nil if the node does not exist' do
+    stub_request(:post, uri).to_return(status: 404, headers: { 'Content-Type' => 'application/json' }, body: "{}")
+
+    expect(described_class.indirection.find(certname)).to be_nil
+  end
+
+  it 'raises if fail_on_404 is specified' do
+    stub_request(:post, uri).to_return(status: 404, headers: { 'Content-Type' => 'application/json' }, body: "{}")
+
+    expect{
+      described_class.indirection.find(certname, fail_on_404: true)
+    }.to raise_error(Puppet::Error, %r{Find /puppet/v3/catalog/ziggy resulted in 404 with the message: {}})
+  end
+
+  it 'raises Net::HTTPError on 500' do
+    stub_request(:post, uri).to_return(status: 500)
+
+    expect{
+      described_class.indirection.find(certname)
+    }.to raise_error(Net::HTTPError, %r{Error 500 on SERVER: })
   end
 end