puppet 4.5.3-universal-darwin → 4.6.1-universal-darwin

data/lib/puppet/generate/type.rb

@@ -0,0 +1,239 @@
+require 'erb'
+require 'fileutils'
+require 'puppet/util/autoload'
+require 'puppet/generate/models/type/type'
+
+module Puppet
+  module Generate
+    # Reponsible for generating type definitions in Puppet
+    class Type
+      # Represents an input to the type generator
+      class Input
+        # Gets the path to the input.
+        attr_reader :path
+
+        # Gets the format to use for generating the output file.
+        attr_reader :format
+
+        # Initializes an input.
+        # @param base [String] The base path where the input is located.
+        # @param path [String] The path to the input file.
+        # @param format [Symbol] The format to use for generation.
+        # @return [void]
+        def initialize(base, path, format)
+          @base = base
+          @path = path
+          self.format = format
+        end
+
+        # Gets the expected resource type name for the input.
+        # @return [Symbol] Returns the expected resource type name for the input.
+        def type_name
+          File.basename(@path, '.rb').to_sym
+        end
+
+        # Sets the format to use for this input.
+        # @param format [Symbol] The format to use for generation.
+        # @return [Symbol] Returns the new format.
+        def format=(format)
+          format = format.to_sym
+          raise "unsupported format '#{format}'." unless self.class.supported_format?(format)
+          @format = format
+        end
+
+        # Determines if the output file is up-to-date with respect to the input file.
+        # @param [String, nil] The path to output to, or nil if determined by input
+        # @return [Boolean] Returns true if the output is up-to-date or false if not.
+        def up_to_date?(outputdir)
+          f = effective_output_path(outputdir)
+          Puppet::FileSystem::exist?(f) && (Puppet::FileSystem::stat(@path) <=> Puppet::FileSystem::stat(f)) <= 0
+        end
+
+        # Gets the filename of the output file.
+        # @return [String] Returns the name to the output file.
+        def output_name
+          @output_name ||=
+            case @format
+            when :pcore
+              "#{File.basename(@path, '.rb')}.pp"
+            else
+              raise "unsupported format '#{@format}'."
+            end
+        end
+
+        # Gets the path to the output file.
+        # @return [String] Returns the path to the output file.
+        def output_path
+          @output_path ||=
+            case @format
+            when :pcore
+              File.join(@base, 'pcore', 'types', output_name)
+            else
+              raise "unsupported format '#{@format}'."
+            end
+        end
+
+        # Sets the path to the output file.
+        # @param path [String] The new path to the output file.
+        # @return [String] Returns the new path to the output file.
+        def output_path=(path)
+          @output_path = path
+        end
+
+        # Returns the outputpath to use given an outputdir that may be nil
+        # If outputdir is not nil, the returned path is relative to that outpudir
+        # otherwise determined by this input.
+        # @param [String, nil] The outputdirectory to use, or nil if to be determined by this Input
+        def effective_output_path(outputdir)
+          outputdir ? File.join(outputdir, output_name) : output_path
+        end
+
+        # Gets the path to the template to use for this input.
+        # @return [String] Returns the path to the template.
+        def template_path
+          File.join(File.dirname(__FILE__), 'templates', 'type', "#{@format}.erb")
+        end
+
+        # Gets the string representation of the input.
+        # @return [String] Returns the string representation of the input.
+        def to_s
+          @path
+        end
+
+        # Determines if the given format is supported
+        # @param format [Symbol] The format to use for generation.
+        # @return [Boolean] Returns true if the format is supported or false if not.
+        def self.supported_format?(format)
+          [:pcore].include?(format)
+        end
+      end
+
+      # Finds the inputs for the generator.
+      # @param format [Symbol] The format to use.
+      # @param environment [Puppet::Node::Environment] The environment to search for inputs. Defaults to the current environment.
+      # @return [Array<Input>] Returns the array of inputs.
+      def self.find_inputs(format = :pcore, environment = Puppet.lookup(:current_environment))
+        Puppet.debug "Searching environment '#{environment.name}' for custom types."
+        inputs = []
+        environment.modules.each do |mod|
+          directory = File.join(Puppet::Util::Autoload.cleanpath(mod.plugin_directory), 'puppet', 'type')
+          unless Puppet::FileSystem.exist?(directory)
+            Puppet.debug "Skipping '#{mod.name}' module because it contains no custom types."
+            next
+          end
+
+          Puppet.debug "Searching '#{mod.name}' module for custom types."
+          Dir.glob("#{directory}/*.rb") do |file|
+            next unless Puppet::FileSystem.file?(file)
+            Puppet.debug "Found custom type source file '#{file}'."
+            inputs << Input.new(mod.path, file, format)
+          end
+        end
+
+        # Sort the inputs by path
+        inputs.sort_by! { |input| input.path }
+      end
+
+      # Generates files for the given inputs.
+      # If a file is up to date (newer than input) it is kept.
+      # If a file is out of date it is regenerated.
+      # If there is a file for a non existing output in a given output directory it is removed.
+      # If using input specific output removal must be made by hand if input is removed.
+      #
+      # @param inputs [Array<Input>] The inputs to generate files for.
+      # @param outputdir [String, nil] the outputdir where all output should be generated, or nil if next to input
+      # @param force [Boolean] True to force the generation of the output files (skip up-to-date checks) or false if not.
+      # @return [void]
+      def self.generate(inputs, outputdir = nil, force = false)
+        # remove files for non existing inputs
+        unless outputdir.nil?
+          filenames_to_keep = inputs.map {|i| i.output_name }
+          existing_files = Puppet::FileSystem.children(outputdir).map {|f| Puppet::FileSystem.basename(f) }
+          files_to_remove = existing_files - filenames_to_keep
+          files_to_remove.each do |f|
+            Puppet::FileSystem.unlink(File.join(outputdir, f))
+          end
+          Puppet.notice("Removed output '#{files_to_remove}' for non existing inputs") unless files_to_remove.empty?
+        end
+
+        if inputs.empty?
+          Puppet.notice 'No custom types were found.'
+          return nil
+        end
+
+        templates = {}
+        templates.default_proc = lambda { |hash, key|
+          raise "template was not found at '#{key}'." unless Puppet::FileSystem.file?(key)
+          template = ERB.new(File.read(key), nil, '-')
+          template.filename = key
+          template
+        }
+
+        up_to_date = true
+        Puppet.notice 'Generating Puppet resource types.'
+        inputs.each do |input|
+          if !force && input.up_to_date?(outputdir)
+            Puppet.debug "Skipping '#{input}' because it is up-to-date."
+            next
+          end
+
+          up_to_date = false
+
+          type_name = input.type_name
+          Puppet.debug "Loading custom type '#{type_name}' in '#{input}'."
+          begin
+            require input.path
+          rescue SystemExit
+            raise
+          rescue Exception => e
+            # Log the exception and move on to the next input
+            Puppet.log_exception(e, "Failed to load custom type '#{type_name}' from '#{input}': #{e.message}")
+            next
+          end
+
+          # HACK: there's no way to get a type without loading it (sigh); for now, just get the types hash directly
+          types ||= Puppet::Type.instance_variable_get('@types')
+
+          # Assume the type follows the naming convention
+          unless type = types[type_name]
+            Puppet.err "Custom type '#{type_name}' was not defined in '#{input}'."
+            next
+          end
+
+          # Create the model
+          begin
+            model = Models::Type::Type.new(type)
+          rescue Exception => e
+            # Move on to the next input
+            Puppet.log_exception(e, "#{input}: #{e.message}")
+            next
+          end
+
+          # Render the template
+          begin
+            result = model.render(templates[input.template_path])
+          rescue Exception => e
+            Puppet.log_exception(e)
+            raise
+          end
+
+          # Write the output file
+          begin
+            effective_output_path = input.effective_output_path(outputdir)
+            Puppet.notice "Generating '#{effective_output_path}' using '#{input.format}' format."
+            FileUtils.mkdir_p(File.dirname(effective_output_path))
+            File.open(effective_output_path, 'w') do |file|
+              file.write(result)
+            end
+          rescue Exception => e
+            Puppet.log_exception(e, "Failed to generate '#{effective_output_path}': #{e.message}")
+            # Move on to the next input
+            next
+          end
+        end
+
+        Puppet.notice 'No files were generated because all inputs were up-to-date.' if up_to_date
+      end
+    end
+  end
+end

data/lib/puppet/graph/simple_graph.rb

@@ -246,8 +246,6 @@ class Puppet::Graph::SimpleGraph
     # This does not use the DOT graph library, just writes the content
     # directly.  Given the complexity of this, there didn't seem much point
     # using a heavy library to generate exactly the same content. --daniel 2011-01-27
-    Puppet.settings.use(:graphing)
-
     graph = ["digraph Resource_Cycles {"]
     graph << '  label = "Resource Cycles"'
 
@@ -401,7 +399,7 @@ class Puppet::Graph::SimpleGraph
   end
 
   # Return an array of the edge-sets between a series of n+1 vertices (f=v0,v1,v2...t=vn)
-  #   connecting the two given verticies.  The ith edge set is an array containing all the
+  #   connecting the two given vertices.  The ith edge set is an array containing all the
   #   edges between v(i) and v(i+1); these are (by definition) never empty.
   #
   #     * if f == t, the list is empty
@@ -464,15 +462,13 @@ class Puppet::Graph::SimpleGraph
   def write_graph(name)
     return unless Puppet[:graph]
 
-    Puppet.settings.use(:graphing)
-
     file = File.join(Puppet[:graphdir], "#{name}.dot")
     File.open(file, "w") { |f|
       f.puts to_dot("name" => name.to_s.capitalize)
     }
   end
 
-  # This flag may be set to true to use the new YAML serialzation
+  # This flag may be set to true to use the new YAML serialization
   # format (where @vertices is a simple list of vertices rather than a
   # list of VertexWrapper objects).  Deserialization supports both
   # formats regardless of the setting of this flag.

data/lib/puppet/indirector/catalog/static_compiler.rb

@@ -97,14 +97,17 @@ class Puppet::Resource::Catalog::StaticCompiler < Puppet::Resource::Catalog::Com
     resource[:mode] ||= metadata.send(:mode).to_s(8)
 
     resource[:ensure] = metadata.ftype
-    if metadata.ftype == "file"
+    case resource[:ensure]
+    when 'file'
       unless resource[:content]
         resource[:content] = metadata.checksum
         resource[:checksum] = metadata.checksum_type
       end
+      store_content(request, resource)
+    when 'link'
+      resource[:target] = metadata.destination
     end
 
-    store_content(request, resource) if resource[:ensure] == "file"
     old_source = resource.delete(:source)
     Puppet.info "Metadata for #{resource} in catalog for '#{request.key}' added from '#{old_source}'"
   end

data/lib/puppet/indirector/facts/facter.rb

@@ -26,7 +26,7 @@ class Puppet::Node::Facts::Facter < Puppet::Indirector::Code
     # fact. This is because in Facter 2.x, the first `Facter.add` causes Facter to create
     # its directory loaders which cannot be changed, meaning other external facts won't
     # be resolved. (PUP-4607)
-    self.class.setup_external_search_paths(request) if Puppet.features.external_facts?
+    self.class.setup_external_search_paths(request)
     self.class.setup_search_paths(request)
 
     # Initialize core Puppet facts, such as puppetversion

data/lib/puppet/indirector/key/ca.rb

@@ -2,8 +2,8 @@ require 'puppet/indirector/ssl_file'
 require 'puppet/ssl/key'
 
 class Puppet::SSL::Key::Ca < Puppet::Indirector::SslFile
-  desc "Manage the CA's private on disk.  This terminus *only* works
-    with the CA key, because that's the only key that the CA ever interacts
+  desc "Manage the CA's private key on disk. This terminus works with the
+    CA key *only*, because that's the only key that the CA ever interacts
     with."
 
   store_in :privatekeydir

data/lib/puppet/indirector/request.rb

@@ -178,7 +178,7 @@ class Puppet::Indirector::Request
     return(uri ? uri : "/#{indirection_name}/#{key}")
   end
 
-  def do_request(srv_service=:puppet, default_server=Puppet.settings[:server], default_port=Puppet.settings[:masterport], &block)
+  def do_request(srv_service=:puppet, default_server=nil, default_port=nil, &block)
     # We were given a specific server to use, so just use that one.
     # This happens if someone does something like specifying a file
     # source using a puppet:// URI with a specific server.
@@ -197,9 +197,30 @@ class Puppet::Indirector::Request
     end
 
     # ... Fall back onto the default server.
-    Puppet.debug "No more servers left, falling back to #{default_server}:#{default_port}" if Puppet.settings[:use_srv_records]
-    self.server = default_server
-    self.port   = default_port
+    begin
+      bound_server = Puppet.lookup(:server)
+    rescue
+      if primary_server = Puppet.settings[:server_list][0]
+        bound_server = primary_server[0]
+      else
+        bound_server = nil
+      end
+    end
+
+    begin
+      bound_port = Puppet.lookup(:serverport)
+    rescue
+      if primary_server = Puppet.settings[:server_list][0]
+        bound_port = primary_server[1]
+      else
+        bound_port = nil
+      end
+    end
+    self.server = default_server || bound_server || Puppet.settings[:server]
+    self.port   = default_port || bound_port || Puppet.settings[:masterport]
+
+    Puppet.debug "No more servers left, falling back to #{self.server}:#{self.port}" if Puppet.settings[:use_srv_records]
+
     return yield(self)
   end
 

data/lib/puppet/indirector/rest.rb

@@ -1,5 +1,6 @@
 require 'net/http'
 require 'uri'
+require 'json'
 
 require 'puppet/network/http'
 require 'puppet/network/http_pool'
@@ -33,12 +34,68 @@ class Puppet::Indirector::REST < Puppet::Indirector::Terminus
     @srv_service || :puppet
   end
 
+  # The logic for server and port is kind of gross. In summary:
+  # IF an endpoint-specific setting is requested AND that setting has been set by the user
+  #    Use that setting.
+  #         The defaults for these settings are the "normal" server/masterport settings, so
+  #         when they are unset we instead want to "fall back" to the failover-selected
+  #         host/port pair.
+  # ELSE IF we have a failover-selected host/port
+  #    Use what the failover logic came up with
+  # ELSE IF the server_list setting is in use
+  #    Use the first entry - failover hasn't happened yet, but that
+  #    setting is still authoritative
+  # ELSE
+  #    Go for the legacy server/masterport settings, and hope for the best
   def self.server
-    Puppet.settings[server_setting || :server]
+    setting = server_setting()
+    if setting && setting != :server && Puppet.settings.set_by_config?(setting)
+      Puppet.settings[setting]
+    else
+      begin
+        Puppet.lookup(:server)
+      rescue
+        if primary_server = Puppet.settings[:server_list][0]
+          Puppet.debug "Dynamically-bound server lookup failed; using first entry"
+          primary_server[0]
+        else
+          setting ||= :server
+          Puppet.debug "Dynamically-bound server lookup failed, falling back to #{setting} setting"
+          Puppet.settings[setting]
+        end
+      end
+    end
   end
 
+  # For port there's a little bit of an extra snag: setting a specific
+  # server setting and relying on the default port for that server is
+  # common, so we also want to check if the assocaited SERVER setting
+  # has been set by the user. If either of those are set we ignore the
+  # failover-selected port.
   def self.port
-    Puppet.settings[port_setting || :masterport].to_i
+    setting = port_setting()
+    srv_setting = server_setting()
+    if (setting && setting != :masterport && Puppet.settings.set_by_config?(setting)) ||
+       (srv_setting && srv_setting != :server && Puppet.settings.set_by_config?(srv_setting))
+      Puppet.settings[setting].to_i
+    else
+      begin
+        Puppet.lookup(:serverport).to_i
+      rescue
+        if primary_server = Puppet.settings[:server_list][0]
+          Puppet.debug "Dynamically-bound port lookup failed; using first entry"
+
+          # Port might not be set, so we want to fallback in that
+          # case. We know we don't need to use `setting` here, since
+          # the default value of every port setting is `masterport`
+          (primary_server[1] || Puppet.settings[:masterport]).to_i
+        else
+          setting ||= :masterport
+          Puppet.debug "Dynamically-bound port lookup failed; falling back to #{setting} setting"
+          Puppet.settings[setting].to_i
+        end
+      end
+    end
   end
 
   # Provide appropriate headers.
@@ -218,7 +275,20 @@ class Puppet::Indirector::REST < Puppet::Indirector::Terminus
   end
 
   def convert_to_http_error(response)
-    message = "Error #{response.code} on SERVER: #{(response.body||'').empty? ? response.message : uncompress_body(response)}"
+    if response.body.to_s.empty? && response.respond_to?(:message)
+      returned_message = response.message
+    elsif response['content-type'].is_a?(String)
+      content_type, body = parse_response(response)
+      if content_type =~ /[pj]son/
+        returned_message = JSON.parse(body)["message"]
+      else
+        returned_message = uncompress_body(response)
+      end
+    else
+      returned_message = uncompress_body(response)
+    end
+
+    message = "Error #{response.code} on SERVER: #{returned_message}"
     Net::HTTPError.new(message, response)
   end