puppet 3.6.2-x86-mingw32 → 3.7.0-x86-mingw32

data/lib/puppet/network/http/pool.rb

@@ -0,0 +1,120 @@
+# A pool for persistent <tt>Net::HTTP</tt> connections. Connections are
+# stored in the pool indexed by their {Puppet::Network::HTTP::Site Site}.
+# Connections are borrowed from the pool, yielded to the caller, and
+# released back into the pool. If a connection is expired, it will be
+# closed either when a connection to that site is requested, or when
+# the pool is closed. The pool can store multiple connections to the
+# same site, and will be reused in MRU order.
+#
+# @api private
+#
+class Puppet::Network::HTTP::Pool
+  FIFTEEN_SECONDS = 15
+
+  attr_reader :factory
+
+  def initialize(keepalive_timeout = FIFTEEN_SECONDS)
+    @pool = {}
+    @factory = Puppet::Network::HTTP::Factory.new
+    @keepalive_timeout = keepalive_timeout
+  end
+
+  def with_connection(site, verify, &block)
+    reuse = true
+
+    http = borrow(site, verify)
+    begin
+      if http.use_ssl? && http.verify_mode != OpenSSL::SSL::VERIFY_PEER
+        reuse = false
+      end
+
+      yield http
+    rescue => detail
+      reuse = false
+      raise detail
+    ensure
+      if reuse
+        release(site, http)
+      else
+        close_connection(site, http)
+      end
+    end
+  end
+
+  def close
+    @pool.each_pair do |site, sessions|
+      sessions.each do |session|
+        close_connection(site, session.connection)
+      end
+    end
+    @pool.clear
+  end
+
+  # @api private
+  def pool
+    @pool
+  end
+
+  # Safely close a persistent connection.
+  #
+  # @api private
+  def close_connection(site, http)
+    Puppet.debug("Closing connection for #{site}")
+    http.finish
+  rescue => detail
+    Puppet.log_exception(detail, "Failed to close connection for #{site}: #{detail}")
+  end
+
+  # Borrow and take ownership of a persistent connection. If a new
+  # connection is created, it will be started prior to being returned.
+  #
+  # @api private
+  def borrow(site, verify)
+    @pool[site] = active_sessions(site)
+    session = @pool[site].shift
+    if session
+      Puppet.debug("Using cached connection for #{site}")
+      session.connection
+    else
+      http = @factory.create_connection(site)
+      verify.setup_connection(http)
+
+      Puppet.debug("Starting connection for #{site}")
+      http.start
+      http
+    end
+  end
+
+  # Release a connection back into the pool.
+  #
+  # @api private
+  def release(site, http)
+    expiration = Time.now + @keepalive_timeout
+    session = Puppet::Network::HTTP::Session.new(http, expiration)
+    Puppet.debug("Caching connection for #{site}")
+
+    sessions = @pool[site]
+    if sessions
+      sessions.unshift(session)
+    else
+      @pool[site] = [session]
+    end
+  end
+
+  # Returns an Array of sessions whose connections are not expired.
+  #
+  # @api private
+  def active_sessions(site)
+    now = Time.now
+
+    sessions = @pool[site] || []
+    sessions.select do |session|
+      if session.expired?(now)
+        close_connection(site, session.connection)
+        false
+      else
+        true
+      end
+    end
+  end
+end

data/lib/puppet/network/http/rack/rest.rb

@@ -94,7 +94,9 @@ class Puppet::Network::HTTP::RackREST
     if cert.nil? || cert.empty?
       nil
     else
-      Puppet::SSL::Certificate.from_instance(OpenSSL::X509::Certificate.new(cert))
+      cert = Puppet::SSL::Certificate.from_instance(OpenSSL::X509::Certificate.new(cert))
+      warn_if_near_expiration(cert)
+      cert
     end
   end
 

data/lib/puppet/network/http/session.rb

@@ -0,0 +1,17 @@
+# An HTTP session that references a persistent HTTP connection and
+# an expiration time for the connection.
+#
+# @api private
+#
+class Puppet::Network::HTTP::Session
+  attr_reader :connection
+
+  def initialize(connection, expiration_time)
+    @connection = connection
+    @expiration_time = expiration_time
+  end
+
+  def expired?(now)
+    @expiration_time <= now
+  end
+end

data/lib/puppet/network/http/site.rb

@@ -0,0 +1,39 @@
+# Represents a site to which HTTP connections are made. It is a value
+# object, and is suitable for use in a hash. If two sites are equal,
+# then a persistent connection made to the first site, can be re-used
+# for the second.
+#
+# @api private
+#
+class Puppet::Network::HTTP::Site
+  attr_reader :scheme, :host, :port
+
+  def initialize(scheme, host, port)
+    @scheme = scheme
+    @host = host
+    @port = port.to_i
+  end
+
+  def addr
+    "#{@scheme}://#{@host}:#{@port.to_s}"
+  end
+  alias to_s addr
+
+  def ==(rhs)
+    (@scheme == rhs.scheme) && (@host == rhs.host) && (@port == rhs.port)
+  end
+
+  alias eql? ==
+
+  def hash
+    [@scheme, @host, @port].hash
+  end
+
+  def use_ssl?
+    @scheme == 'https'
+  end
+
+  def move_to(uri)
+    self.class.new(uri.scheme, uri.host, uri.port)
+  end
+end

data/lib/puppet/network/http/webrick/rest.rb

@@ -60,7 +60,9 @@ class Puppet::Network::HTTP::WEBrickREST < WEBrick::HTTPServlet::AbstractServlet
 
   def client_cert(request)
     if cert = request.client_cert
-      Puppet::SSL::Certificate.from_instance(cert)
+      cert = Puppet::SSL::Certificate.from_instance(cert)
+      warn_if_near_expiration(cert)
+      cert
     else
       nil
     end

data/lib/puppet/network/http_pool.rb

@@ -3,10 +3,9 @@ require 'puppet/network/http/connection'
 module Puppet::Network; end
 
 # This module contains the factory methods that should be used for getting a
-# {Puppet::Network::HTTP::Connection} instance.
-#
-# @note The name "HttpPool" is a misnomer, and a leftover of history, but we would
-#   like to make this cache connections in the future.
+# {Puppet::Network::HTTP::Connection} instance. The pool may return a new
+# connection or a persistent cached connection, depending on the underlying
+# pool implementation in use.
 #
 # @api public
 #

data/lib/puppet/node.rb

@@ -13,7 +13,7 @@ class Puppet::Node
   indirects :node, :terminus_setting => :node_terminus, :doc => "Where to find node information.
     A node is composed of its name, its facts, and its environment."
 
-  attr_accessor :name, :classes, :source, :ipaddress, :parameters, :trusted_data
+  attr_accessor :name, :classes, :source, :ipaddress, :parameters, :trusted_data, :environment_name
   attr_reader :time, :facts
 
   ::PSON.register_document_type('Node',self)
@@ -24,7 +24,7 @@ class Puppet::Node
     node = new(name)
     node.classes = data['classes']
     node.parameters = data['parameters']
-    node.environment = data['environment']
+    node.environment_name = data['environment']
     node
   end
 
@@ -57,11 +57,20 @@ class Puppet::Node
   def environment
     if @environment
       @environment
-    elsif env = parameters["environment"]
-      self.environment = env
-      @environment
     else
-      Puppet.lookup(:environments).get(Puppet[:environment])
+      if env = parameters["environment"]
+        self.environment = env
+      elsif environment_name
+        self.environment = environment_name
+      else
+        # This should not be :current_environment, this is the default
+        # for a node when it has not specified its environment
+        # Tt will be used to establish what the current environment is.
+        #
+        self.environment = Puppet.lookup(:environments).get(Puppet[:environment])
+      end
+
+      @environment
     end
   end
 
@@ -73,6 +82,10 @@ class Puppet::Node
     end
   end
 
+  def has_environment_instance?
+    !@environment.nil?
+  end
+
   def initialize(name, options = {})
     raise ArgumentError, "Node names cannot be nil" unless name
     @name = name

data/lib/puppet/node/environment.rb

@@ -237,6 +237,27 @@ class Puppet::Node::Environment
   #     (optional)
   attr_reader :config_version
 
+  # Checks to make sure that this environment did not have a manifest set in
+  # its original environment.conf if Puppet is configured with
+  # +disable_per_environment_manifest+ set true.  If it did, the environment's
+  # modules may not function as intended by the original authors, and we may
+  # seek to halt a puppet compilation for a node in this environment.
+  #
+  # The only exception to this would be if the environment.conf manifest is an exact,
+  # uninterpolated match for the current +default_manifest+ setting.
+  #
+  # @return [Boolean] true if using directory environments, and
+  #   Puppet[:disable_per_environment_manifest] is true, and this environment's
+  #   original environment.conf had a manifest setting that is not the
+  #   Puppet[:default_manifest].
+  # @api public
+  def conflicting_manifest_settings?
+    return false if Puppet[:environmentpath].empty? || !Puppet[:disable_per_environment_manifest]
+    environment_conf = Puppet.lookup(:environments).get_conf(name)
+    original_manifest = environment_conf.raw_setting(:manifest)
+    !original_manifest.nil? && !original_manifest.empty? && original_manifest != Puppet[:default_manifest]
+  end
+
   # Return an environment-specific Puppet setting.
   #
   # @api public
@@ -432,11 +453,9 @@ class Puppet::Node::Environment
   # This call does nothing unless files are being watched.
   #
   def check_for_reparse
-    if watching?
-      if (Puppet[:code] != @parsed_code) || (@known_resource_types && @known_resource_types.require_reparse?)
-        @parsed_code = nil
-        @known_resource_types = nil
-      end
+    if (Puppet[:code] != @parsed_code) || (watching? && @known_resource_types && @known_resource_types.require_reparse?)
+      @parsed_code = nil
+      @known_resource_types = nil
     end
   end
 
@@ -531,9 +550,16 @@ class Puppet::Node::Environment
       if file == NO_MANIFEST
         Puppet::Parser::AST::Hostclass.new('')
       elsif File.directory?(file)
-        parse_results = Dir.entries(file).find_all { |f| f =~ /\.pp$/ }.sort.map do |pp_file|
-          parser.file = File.join(file, pp_file)
-          parser.parse
+        if Puppet[:parser] == 'future'
+          parse_results = Puppet::FileSystem::PathPattern.absolute(File.join(file, '**/*.pp')).glob.sort.map do | file_to_parse |
+            parser.file = file_to_parse
+            parser.parse
+          end
+        else
+          parse_results = Dir.entries(file).find_all { |f| f =~ /\.pp$/ }.sort.map do |file_to_parse|
+            parser.file = File.join(file, file_to_parse)
+            parser.parse
+          end
         end
         # Use a parser type specific merger to concatenate the results
         Puppet::Parser::AST::Hostclass.new('', :code => Puppet::Parser::ParserFactory.code_merger.concatenate(parse_results))

data/lib/puppet/parser/ast/collection.rb

@@ -15,6 +15,10 @@ class Puppet::Parser::AST
     def evaluate(scope)
       match, code = query && query.safeevaluate(scope)
 
+      if @type == 'class'
+        fail "Classes cannot be collected"
+      end
+
       resource_type = scope.find_resource_type(@type)
       fail "Resource type #{@type} doesn't exist" unless resource_type
       newcoll = Puppet::Parser::Collector.new(scope, resource_type.name, match, code, self.form)

data/lib/puppet/parser/ast/collexpr.rb

@@ -85,7 +85,7 @@ class CollExpr < AST::Branch
           resource.tagged?(match2)
         else
           if resource[match1].is_a?(Array)
-            @@compare_operator.include?(resource[match1], match2)
+            @@compare_operator.include?(resource[match1], match2, scope)
           else
             @@compare_operator.equals(resource[match1], match2)
           end

data/lib/puppet/parser/ast/node.rb

@@ -5,6 +5,11 @@ class Puppet::Parser::AST::Node < Puppet::Parser::AST::TopLevelConstruct
 
   def initialize(names, context = {}, &ruby_code)
     raise ArgumentError, "names should be an array" unless names.is_a? Array
+    if context[:parent]
+      msg = "Deprecation notice: Node inheritance is not supported in Puppet >= 4.0.0. See http://links.puppetlabs.com/puppet-node-inheritance-deprecation"
+      Puppet.puppet_deprecation_warning(msg, :key => "node-inheritance-#{names.join}", :file => context[:file], :line => context[:line])
+    end
+
     @names = names
     @context = context
     @ruby_code = ruby_code

data/lib/puppet/parser/ast/pops_bridge.rb

@@ -16,7 +16,7 @@ class Puppet::Parser::AST::PopsBridge
 
     def initialize args
       super
-      @@evaluator ||= Puppet::Pops::Parser::EvaluatingParser::Transitional.new()
+      @@evaluator ||= Puppet::Pops::Parser::EvaluatingParser.new()
     end
 
     def to_s
@@ -75,7 +75,7 @@ class Puppet::Parser::AST::PopsBridge
       @program_model = program_model
       @context = context
       @ast_transformer ||= Puppet::Pops::Model::AstTransformer.new(@context[:file])
-      @@evaluator ||= Puppet::Pops::Parser::EvaluatingParser::Transitional.new()
+      @@evaluator ||= Puppet::Pops::Parser::EvaluatingParser.new()
     end
 
     # This is the 3x API, the 3x AST searches through all code to find the instructions that can be instantiated.
@@ -117,16 +117,53 @@ class Puppet::Parser::AST::PopsBridge
       # can thus reference all sorts of information. Here the value expression is wrapped in an AST Bridge to a Pops
       # expression since the Pops side can not control the evaluation
       if o.value
-        [ o.name, NilAsUndefExpression.new(:value => o.value) ]
+        [o.name, NilAsUndefExpression.new(:value => o.value)]
       else
-        [ o.name ]
+        [o.name]
       end
     end
 
+    def create_type_map(definition)
+      result = {}
+      # No need to do anything if there are no parameters
+      return result unless definition.parameters.size > 0
+
+      # No need to do anything if there are no typed parameters
+      typed_parameters = definition.parameters.select {|p| p.type_expr }
+      return result if typed_parameters.empty?
+
+      # If there are typed parameters, they need to be evaluated to produce the corresponding type
+      # instances. This evaluation requires a scope. A scope is not available when doing deserialization
+      # (there is also no initialized evaluator). When running apply and test however, the environment is
+      # reused and we may reenter without a scope (which is fine). A debug message is then output in case
+      # there is the need to track down the odd corner case. See {#obtain_scope}.
+      #
+      if scope = obtain_scope
+        typed_parameters.each do |p|
+          result[p.name] =  @@evaluator.evaluate(scope, p.type_expr)
+        end
+      end
+      result
+    end
+
+    # Obtains the scope or issues a warning if :global_scope is not bound
+    def obtain_scope
+      scope = Puppet.lookup(:global_scope) do
+        # This occurs when testing and when applying a catalog (there is no scope available then), and
+        # when running tests that run a partial setup.
+        # This is bad if the logic is trying to compile, but a warning can not be issues since it is a normal
+        # use case that there is no scope when requesting the type in order to just get the parameters.
+        Puppet.debug("Instantiating Resource with type checked parameters - scope is missing, skipping type checking.")
+        nil
+      end
+      scope
+    end
+
     # Produces a hash with data for Definition and HostClass
     def args_from_definition(o, modname)
       args = {
        :arguments => o.parameters.collect {|p| instantiate_Parameter(p) },
+       :argument_types => create_type_map(o),
        :module_name => modname
       }
       unless is_nop?(o.body)
@@ -137,7 +174,7 @@ class Puppet::Parser::AST::PopsBridge
 
     def instantiate_HostClassDefinition(o, modname)
       args = args_from_definition(o, modname)
-      args[:parent] = o.parent_class
+      args[:parent] = absolute_reference(o.parent_class)
       Puppet::Resource::Type.new(:hostclass, o.name, @context.merge(args))
     end
 
@@ -204,6 +241,12 @@ class Puppet::Parser::AST::PopsBridge
       @ast_transformer.is_nop?(o)
     end
 
+    def absolute_reference(ref)
+      if ref.nil? || ref.empty? || ref.start_with?('::')
+        ref
+      else
+        "::#{ref}"
+      end
+    end
   end
-
 end