puppet 3.5.1-x86-mingw32 → 3.6.0.rc1-x86-mingw32

data/lib/puppet/functions/assert_type.rb

@@ -0,0 +1,42 @@
+# Returns the given value if it is an instance of the given type, and raises an error otherwise.
+#
+# @example how to assert type
+#   # assert that `$b` is a non empty `String` and assign to `$a`
+#   $a = assert_type(String[1], $b)
+#
+# See the documentation for "The Puppet Type System" for more information about types.
+#
+Puppet::Functions.create_function(:assert_type) do
+  dispatch :assert_type do
+    param 'Type', 'type'
+    param 'Optional[Object]', 'value'
+  end
+
+  dispatch :assert_type_s do
+    param 'String', 'type_string'
+    param 'Optional[Object]', 'value'
+  end
+
+  # @param type [Type] the type the value must be an instance of
+  # @param value [Optional[Object]] the value to assert
+  #
+  def assert_type(type, value)
+    unless Puppet::Pops::Types::TypeCalculator.instance?(type,value)
+      inferred_type = Puppet::Pops::Types::TypeCalculator.infer(value)
+      # Do not give all the details - i.e. format as Integer, instead of Integer[n, n] for exact value, which
+      # is just confusing. (OTOH: may need to revisit, or provide a better "type diff" output.
+      #
+      actual = Puppet::Pops::Types::TypeCalculator.generalize!(inferred_type)
+      raise Puppet::ParseError, "assert_type(): Expected type #{type} does not match actual: #{actual}"
+    end
+    value
+  end
+
+  # @param type_string [String] the type the value must be an instance of given in String form
+  # @param value [Optional[Object]] the value to assert
+  #
+  def assert_type_s(type_string, value)
+    t = Puppet::Pops::Types::TypeParser.new.parse(type_string)
+    assert_type(t, value)
+  end
+end

data/lib/puppet/functions/import.rb

@@ -0,0 +1,7 @@
+# The import function raises an error when called to inform the user that import is no longer supported.
+#
+Puppet::Functions.create_function(:import) do
+  def import(*args)
+    raise Puppet::Pops::SemanticError.new(Puppet::Pops::Issues::DISCONTINUED_IMPORT)
+  end
+end

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

@@ -15,7 +15,7 @@ class Puppet::Node::Facts::Facter < Puppet::Indirector::Code
 
   def self.load_fact_plugins
     # Add any per-module fact directories to the factpath
-    module_fact_dirs = Puppet[:modulepath].split(File::PATH_SEPARATOR).collect do |d|
+    module_fact_dirs = Puppet.lookup(:current_environment).modulepath.collect do |d|
       ["lib", "plugins"].map do |subdirectory|
         Dir.glob("#{d}/*/#{subdirectory}/facter")
       end

data/lib/puppet/indirector/file_bucket_file/file.rb

@@ -104,8 +104,9 @@ module Puppet::FileBucketFile
       if path == '' # Treat "md5/<checksum>/" like "md5/<checksum>"
         path = nil
       end
-      raise "Unsupported checksum type #{checksum_type.inspect}" if checksum_type != 'md5'
-      raise "Invalid checksum #{checksum.inspect}" if checksum !~ /^[0-9a-f]{32}$/
+      raise ArgumentError, "Unsupported checksum type #{checksum_type.inspect}" if checksum_type != Puppet[:digest_algorithm]
+      expected = method(checksum_type + "_hex_length").call
+      raise "Invalid checksum #{checksum.inspect}" if checksum !~ /^[0-9a-f]{#{expected}}$/
       [checksum, path]
     end
 

data/lib/puppet/indirector/rest.rb

@@ -103,6 +103,20 @@ class Puppet::Indirector::REST < Puppet::Indirector::Terminus
       result = deserialize_find(content_type, body)
       result.name = request.key if result.respond_to?(:name=)
       result
+
+    elsif is_http_404?(response)
+      # 404 gets special treatment as the indirector API can not produce a meaningful
+      # reason to why something is not found - it may not be the thing the user is
+      # expecting to find that is missing, but something else (like the environment).
+      # While this way of handling the issue is not perfect, there is at least a warning
+      # that makes a user aware of the reason for the failure.
+      #
+      content_type, body = parse_response(response)
+      msg = "Find #{uri_with_query_string} resulted in 404 with the message: #{body}"
+      # warn_once
+      Puppet::Util::Warnings.maybe_log(msg, self.class){ Puppet.warning msg }
+      nil
+
     else
       nil
     end
@@ -195,6 +209,10 @@ class Puppet::Indirector::REST < Puppet::Indirector::Terminus
     end
   end
 
+  def is_http_404?(response)
+    response.code == "404"
+  end
+
   def convert_to_http_error(response)
     message = "Error #{response.code} on SERVER: #{(response.body||'').empty? ? response.message : uncompress_body(response)}"
     Net::HTTPError.new(message, response)

data/lib/puppet/loaders.rb

@@ -0,0 +1,20 @@
+module Puppet
+  module Pops
+    require 'puppet/pops/loaders'
+
+    module Loader
+      require 'puppet/pops/loader/loader'
+      require 'puppet/pops/loader/base_loader'
+      require 'puppet/pops/loader/gem_support'
+      require 'puppet/pops/loader/module_loaders'
+      require 'puppet/pops/loader/dependency_loader'
+      require 'puppet/pops/loader/null_loader'
+      require 'puppet/pops/loader/static_loader'
+      require 'puppet/pops/loader/ruby_function_instantiator'
+      require 'puppet/pops/loader/ruby_legacy_function_instantiator'
+      require 'puppet/pops/loader/loader_paths'
+      require 'puppet/pops/loader/simple_environment_loader'
+    end
+  end
+
+end

data/lib/puppet/module.rb

@@ -32,7 +32,7 @@ class Puppet::Module
     env.module(modname)
   end
 
-  attr_reader :name, :environment, :path
+  attr_reader :name, :environment, :path, :metadata
   attr_writer :environment
 
   attr_accessor :dependencies, :forge_name
@@ -113,7 +113,7 @@ class Puppet::Module
   end
 
   def load_metadata
-    data = JSON.parse File.read(metadata_file)
+    @metadata = data = JSON.parse(File.read(metadata_file))
     @forge_name = data['name'].gsub('-', '/') if data['name']
 
     [:source, :author, :version, :license, :puppetversion, :dependencies].each do |attr|

data/lib/puppet/module_tool.rb

@@ -10,7 +10,7 @@ module Puppet
     extend Puppet::Util::Colors
 
     # Directory and names that should not be checksummed.
-    ARTIFACTS = ['pkg', /^\./, /^~/, /^#/, 'coverage', 'metadata.json', 'REVISION']
+    ARTIFACTS = ['pkg', /^\./, /^~/, /^#/, 'coverage', 'checksums.json', 'REVISION']
     FULL_MODULE_NAME_PATTERN = /\A([^-\/|.]+)[-|\/](.+)\z/
     REPOSITORY_URL = Puppet.settings[:module_repository]
 
@@ -56,14 +56,14 @@ module Puppet
     end
 
     # Analyse path to see if it is a module root directory by detecting a
-    # file named 'Modulefile' in the directory.
+    # file named 'metadata.json' or 'Modulefile' in the directory.
     #
     # @param path [Pathname, String] path to analyse
     # @return [Boolean] true if the path is a module root, false otherwise
     def self.is_module_root?(path)
       path = Pathname.new(path) if path.class == String
 
-      FileTest.file?(path + 'Modulefile')
+      FileTest.file?(path + 'metadata.json') || FileTest.file?(path + 'Modulefile')
     end
 
     # Builds a formatted tree from a list of node hashes containing +:text+
@@ -90,16 +90,19 @@ module Puppet
 
     def self.build_tree(mods, dir)
       mods.each do |mod|
-        version_string = mod[:version][:vstring].sub(/^(?!v)/, 'v')
+        version_string = mod[:version].to_s.sub(/^(?!v)/, 'v')
 
         if mod[:action] == :upgrade
-          previous_version = mod[:previous_version].sub(/^(?!v)/, 'v')
+          previous_version = mod[:previous_version].to_s.sub(/^(?!v)/, 'v')
           version_string = "#{previous_version} -> #{version_string}"
         end
 
-        mod[:text] = "#{mod[:module]} (#{colorize(:cyan, version_string)})"
-        mod[:text] += " [#{mod[:path]}]" unless mod[:path] == dir
-        build_tree(mod[:dependencies], dir)
+        mod[:text] = "#{mod[:name]} (#{colorize(:cyan, version_string)})"
+        mod[:text] += " [#{mod[:path]}]" unless mod[:path].to_s == dir.to_s
+
+        deps = (mod[:dependencies] || [])
+        deps.sort! { |a, b| a[:name] <=> b[:name] }
+        build_tree(deps, dir)
       end
     end
 
@@ -111,23 +114,46 @@ module Puppet
     # modifying the options parameter.  This same hash is referenced both
     # when_invoked and when_rendering.  For this reason, we are not returning
     # a duplicate.
+    # @todo Validate the above note...
     #
     # An :environment_instance and a :target_dir are added/updated in the
     # options parameter.
     #
     # @api private
     def self.set_option_defaults(options)
-      current_environment = Puppet.lookup(:current_environment)
-      modulepath =  [options[:target_dir]] + current_environment.full_modulepath
+      current_environment = environment_from_options(options)
+
+      modulepath = [options[:target_dir]] + current_environment.full_modulepath
 
-      face_environment = current_environment.override_with(
-        :modulepath => modulepath.compact
-      )
+      face_environment = current_environment.override_with(:modulepath => modulepath.compact)
 
       options[:environment_instance] = face_environment
+
       # Note: environment will have expanded the path
       options[:target_dir] = face_environment.full_modulepath.first
     end
+
+    # Given a hash of options, we should discover or create a
+    # {Puppet::Node::Environment} instance that reflects the provided options.
+    #
+    # Generally speaking, the `:modulepath` parameter should supercede all
+    # others, the `:environment` parameter should follow after that, and we
+    # should default to Puppet's current environment.
+    #
+    # @param options [{Symbol => Object}] the options to derive environment from
+    # @return [Puppet::Node::Environment] the environment described by the options
+    def self.environment_from_options(options)
+      if options[:modulepath]
+        path = options[:modulepath].split(File::PATH_SEPARATOR)
+        Puppet::Node::Environment.create(:anonymous, path, '')
+      elsif options[:environment].is_a?(Puppet::Node::Environment)
+        options[:environment]
+      elsif options[:environment]
+        Puppet.lookup(:environments).get(options[:environment])
+      else
+        Puppet.lookup(:current_environment)
+      end
+    end
   end
 end
 
@@ -139,5 +165,5 @@ require 'puppet/module_tool/contents_description'
 require 'puppet/module_tool/dependency'
 require 'puppet/module_tool/metadata'
 require 'puppet/module_tool/modulefile'
-require 'puppet/module_tool/skeleton'
+require 'puppet/forge/cache'
 require 'puppet/forge'

data/lib/puppet/module_tool/applications.rb

@@ -5,7 +5,6 @@ module Puppet::ModuleTool
     require 'puppet/module_tool/applications/application'
     require 'puppet/module_tool/applications/builder'
     require 'puppet/module_tool/applications/checksummer'
-    require 'puppet/module_tool/applications/generator'
     require 'puppet/module_tool/applications/installer'
     require 'puppet/module_tool/applications/searcher'
     require 'puppet/module_tool/applications/unpacker'

data/lib/puppet/module_tool/applications/application.rb

@@ -1,5 +1,6 @@
 require 'net/http'
 require 'semver'
+require 'json'
 require 'puppet/util/colors'
 
 module Puppet::ModuleTool
@@ -26,42 +27,50 @@ module Puppet::ModuleTool
         when Net::HTTPOK, Net::HTTPCreated
           Puppet.notice success
         else
-          errors = PSON.parse(response.body)['error'] rescue "HTTP #{response.code}, #{response.body}"
+          errors = JSON.parse(response.body)['error'] rescue "HTTP #{response.code}, #{response.body}"
           Puppet.warning "#{failure} (#{errors})"
         end
       end
 
-      def metadata(require_modulefile = false)
-        unless @metadata
-          unless @path
-            raise ArgumentError, "Could not determine module path"
-          end
-          @metadata = Puppet::ModuleTool::Metadata.new
-          contents = ContentsDescription.new(@path)
-          contents.annotate(@metadata)
-          checksums = Checksums.new(@path)
-          checksums.annotate(@metadata)
-          modulefile_path = File.join(@path, 'Modulefile')
-          if File.file?(modulefile_path)
-            Puppet::ModuleTool::ModulefileReader.evaluate(@metadata, modulefile_path)
-          elsif require_modulefile
-            raise ArgumentError, "No Modulefile found."
+      def metadata(require_metadata = false)
+        return @metadata if @metadata
+        @metadata = Puppet::ModuleTool::Metadata.new
+
+        unless @path
+          raise ArgumentError, "Could not determine module path"
+        end
+
+        modulefile_path = File.join(@path, 'Modulefile')
+        metadata_path   = File.join(@path, 'metadata.json')
+
+        if File.file?(modulefile_path)
+          if File.file?(metadata_path)
+            Puppet.warning "Modulefile is deprecated. Using metadata.json."
+          else
+            Puppet.warning "Modulefile is deprecated. Building metadata.json from Modulefile."
           end
-          extra_metadata_path = File.join(@path, 'metadata.json')
-          if File.file?(extra_metadata_path)
-            File.open(extra_metadata_path) do |f|
-              begin
-                @metadata.extra_metadata = PSON.load(f)
-              rescue PSON::ParserError
-                raise ArgumentError, "Could not parse JSON #{extra_metadata_path}", $!.backtrace
-              end
+        end
+
+        if File.file?(metadata_path)
+          File.open(metadata_path) do |f|
+            begin
+              @metadata.update(JSON.load(f))
+            rescue JSON::ParserError => ex
+              raise ArgumentError, "Could not parse JSON #{metadata_path}", ex.backtrace
             end
           end
+
+        elsif File.file?(modulefile_path)
+          Puppet::ModuleTool::ModulefileReader.evaluate(@metadata, modulefile_path)
+
+        elsif require_metadata
+          raise ArgumentError, "No metadata found for module #{@path}"
         end
-        @metadata
+
+        return @metadata
       end
 
-      def load_modulefile!
+      def load_metadata!
         @metadata = nil
         metadata(true)
       end

data/lib/puppet/module_tool/applications/builder.rb

@@ -1,4 +1,5 @@
 require 'fileutils'
+require 'json'
 
 module Puppet::ModuleTool
   module Applications
@@ -11,10 +12,10 @@ module Puppet::ModuleTool
       end
 
       def run
-        load_modulefile!
+        load_metadata!
         create_directory
         copy_contents
-        add_metadata
+        write_json
         Puppet.notice "Building #{@path} for release"
         pack
         relative = Pathname.new(archive_file).relative_path_from(Pathname.new(File.expand_path(Dir.pwd)))
@@ -40,7 +41,7 @@ module Puppet::ModuleTool
       def pack
         FileUtils.rm archive_file rescue nil
 
-        tar = Puppet::ModuleTool::Tar.instance(metadata.full_module_name)
+        tar = Puppet::ModuleTool::Tar.instance
         Dir.chdir(@pkg_path) do
           tar.pack(metadata.release_name, archive_file)
         end
@@ -65,9 +66,18 @@ module Puppet::ModuleTool
         end
       end
 
-      def add_metadata
-        File.open(File.join(build_path, 'metadata.json'), 'w') do |f|
-          f.write(PSON.pretty_generate(metadata))
+      def write_json
+        metadata_path = File.join(build_path, 'metadata.json')
+
+        unless File.exist?(metadata_path)
+          # Legacy build: Metadata was parsed from Modulefile; write it out
+          File.open(metadata_path, 'w') do |f|
+            f.write(metadata.to_json)
+          end
+        end
+
+        File.open(File.join(build_path, 'checksums.json'), 'w') do |f|
+          f.write(PSON.pretty_generate(Checksums.new(@path)))
         end
       end
 

data/lib/puppet/module_tool/applications/checksummer.rb

@@ -1,3 +1,4 @@
+require 'json'
 require 'puppet/module_tool/checksums'
 
 module Puppet::ModuleTool
@@ -11,23 +12,16 @@ module Puppet::ModuleTool
 
       def run
         changes = []
-        if metadata_file.exist?
-          sums = Puppet::ModuleTool::Checksums.new(@path)
-          (metadata['checksums'] || {}).each do |child_path, canonical_checksum|
-
-            # Work around an issue where modules built with an older version
-            # of PMT would include the metadata.json file in the list of files
-            # checksummed. This causes metadata.json to always report local
-            # changes.
-            next if File.basename(child_path) == "metadata.json"
-
-            path = @path + child_path
-            unless path.exist? && canonical_checksum == sums.checksum(path)
-              changes << child_path
-            end
+        sums = Puppet::ModuleTool::Checksums.new(@path)
+        checksums.each do |child_path, canonical_checksum|
+
+          # Avoid checksumming the checksums.json file
+          next if File.basename(child_path) == "checksums.json"
+
+          path = @path + child_path
+          unless path.exist? && canonical_checksum == sums.checksum(path)
+            changes << child_path
           end
-        else
-          raise ArgumentError, "No metadata.json found."
         end
 
         # Return an Array of strings representing file paths of files that have
@@ -44,12 +38,24 @@ module Puppet::ModuleTool
 
       private
 
-      def metadata
-        PSON.parse(metadata_file.read)
+      def checksums
+        if checksums_file.exist?
+          JSON.parse(checksums_file.read)
+        elsif metadata_file.exist?
+          # Check metadata.json too; legacy modules store their checksums there.
+          JSON.parse(metadata_file.read)['checksums'] or
+          raise ArgumentError, "No file containing checksums found."
+        else
+          raise ArgumentError, "No file containing checksums found."
+        end
       end
 
       def metadata_file
-        (@path + 'metadata.json')
+        @path + 'metadata.json'
+      end
+
+      def checksums_file
+        @path + 'checksums.json'
       end
     end
   end