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

data/lib/puppet/module_tool/local_tarball.rb

@@ -0,0 +1,91 @@
+require 'pathname'
+require 'tmpdir'
+
+require 'puppet/forge'
+require 'puppet/module_tool'
+
+module Puppet::ModuleTool
+  class LocalTarball < Semantic::Dependency::Source
+    attr_accessor :release
+
+    def initialize(filename)
+      unpack(filename, tmpdir)
+      Puppet.debug "Unpacked local tarball to #{tmpdir}"
+
+      mod = Puppet::Module.new('tarball', tmpdir, nil)
+      @release = ModuleRelease.new(self, mod)
+    end
+
+    def fetch(name)
+      if @release.name == name
+        [ @release ]
+      else
+        [ ]
+      end
+    end
+
+    def prepare(release)
+      release.mod.path
+    end
+
+    def install(release, dir)
+      staging_dir = release.prepare
+
+      module_dir = dir + release.name[/-(.*)/, 1]
+      module_dir.rmtree if module_dir.exist?
+
+      # Make sure unpacked module has the same ownership as the folder we are moving it into.
+      Puppet::ModuleTool::Applications::Unpacker.harmonize_ownership(dir, staging_dir)
+
+      FileUtils.mv(staging_dir, module_dir)
+    end
+
+    class ModuleRelease < Semantic::Dependency::ModuleRelease
+      attr_reader :mod, :install_dir, :metadata
+
+      def initialize(source, mod)
+        @mod = mod
+        @metadata = mod.metadata
+        name = mod.forge_name.tr('/', '-')
+        version = Semantic::Version.parse(mod.version)
+
+        if mod.dependencies
+          dependencies = mod.dependencies.map do |dep|
+            range = dep['version_requirement'] || dep['versionRequirement'] || '>=0'
+            range = Semantic::VersionRange.parse(range) rescue Semantic::VersionRange::EMPTY_RANGE
+            [ dep['name'].tr('/', '-'), range ]
+          end
+          dependencies = Hash[dependencies]
+        end
+
+        super(source, name, version, dependencies || {})
+      end
+
+      def install(dir)
+        @source.install(self, dir)
+        @install_dir = dir
+      end
+
+      def prepare
+        @source.prepare(self)
+      end
+    end
+
+    private
+
+    # Obtain a suitable temporary path for unpacking tarballs
+    #
+    # @return [String] path to temporary unpacking location
+    def tmpdir
+      @dir ||= Dir.mktmpdir('local-tarball', Puppet::Forge::Cache.base_path)
+    end
+
+    def unpack(file, destination)
+      begin
+        Puppet::ModuleTool::Applications::Unpacker.unpack(file, destination)
+      rescue Puppet::ExecutionFailure => e
+        raise RuntimeError, "Could not extract contents of module archive: #{e.message}"
+      end
+    end
+  end
+end

data/lib/puppet/module_tool/metadata.rb

@@ -1,155 +1,159 @@
 require 'puppet/util/methodhelper'
 require 'puppet/module_tool'
 require 'puppet/network/format_support'
+require 'uri'
+require 'json'
 
 module Puppet::ModuleTool
-  # = Metadata
-  #
+
   # This class provides a data structure representing a module's metadata.
-  # It provides some basic parsing, but other data is injected into it using
-  # +annotate+ methods in other classes.
+  # @api private
   class Metadata
-    include Puppet::Util::MethodHelper
     include Puppet::Network::FormatSupport
 
-    # The full name of the module, which is a dash-separated combination of the
-    # +username+ and module +name+.
-    attr_reader :full_module_name
-
-    # The name of the user that owns this module.
-    attr_reader :username
-
-    # The name of this module. See also +full_module_name+.
-    attr_reader :name
+    attr_accessor :module_name
 
-    # The version of this module.
-    attr_reader :version
-
-    # Instantiate from a hash, whose keys are setters in this class.
-    def initialize(settings={})
-      set_options(settings)
-    end
-
-    # Set the full name of this module, and from it, the +username+ and
-    # module +name+.
-    def full_module_name=(full_module_name)
-      @full_module_name = full_module_name
-      @username, @name = Puppet::ModuleTool::username_and_modname_from(full_module_name)
-    end
-
-    # Return an array of the module's Dependency objects.
-    def dependencies
-      return @dependencies ||= []
-    end
-
-    def author
-      @author || @username
-    end
-
-    def author=(author)
-      @author = author
-    end
-
-    def source
-      @source || 'UNKNOWN'
-    end
-
-    def source=(source)
-      @source = source
-    end
+    DEFAULTS = {
+      'name'         => nil,
+      'version'      => nil,
+      'author'       => nil,
+      'summary'      => nil,
+      'license'      => 'Apache 2.0',
+      'source'       => '',
+      'project_page' => nil,
+      'issues_url'   => nil,
+      'dependencies' => [].freeze,
+    }
 
-    def license
-      @license || 'Apache License, Version 2.0'
+    def initialize
+      @data = DEFAULTS.dup
+      @data['dependencies'] = @data['dependencies'].dup
     end
 
-    def license=(license)
-      @license = license
+    # Returns a filesystem-friendly version of this module name.
+    def dashed_name
+      @data['name'].tr('/', '-') if @data['name']
     end
 
-    def summary
-      @summary || 'UNKNOWN'
-    end
+    # Returns a string that uniquely represents this version of this module.
+    def release_name
+      return nil unless @data['name'] && @data['version']
+      [ dashed_name, @data['version'] ].join('-')
+    end
+
+    alias :name :module_name
+    alias :full_module_name :dashed_name
+
+    # Merges the current set of metadata with another metadata hash.  This
+    # method also handles the validation of module names and versions, in an
+    # effort to be proactive about module publishing constraints.
+    def update(data)
+      process_name(data) if data['name']
+      process_version(data) if data['version']
+      process_source(data) if data['source']
+
+      @data.merge!(data)
+      return self
+    end
+
+    # Returns a hash of the module's metadata.  Used by Puppet's automated
+    # serialization routines.
+    #
+    # @see Puppet::Network::FormatSupport#to_data_hash
+    def to_hash
+      @data
+    end
+    alias :to_data_hash :to_hash
+
+    def to_json
+      # This is used to simulate an ordered hash.  In particular, some keys
+      # are promoted to the top of the serialized hash (while others are
+      # demoted) for human-friendliness.
+      #
+      # This particularly works around the lack of ordered hashes in 1.8.7.
+      promoted_keys = %w[ name version author summary license source ]
+      demoted_keys = %w[ dependencies ]
+      keys = @data.keys
+      keys -= promoted_keys
+      keys -= demoted_keys
+
+      contents = (promoted_keys + keys + demoted_keys).map do |k|
+        value = (JSON.pretty_generate(@data[k]) rescue @data[k].to_json)
+        "#{k.to_json}: #{value}"
+      end
 
-    def summary=(summary)
-      @summary = summary
+      "{\n" + contents.join(",\n").gsub(/^/, '  ') + "\n}\n"
     end
 
-    def description
-      @description || 'UNKNOWN'
+    # Expose any metadata keys as callable reader methods.
+    def method_missing(name, *args)
+      return @data[name.to_s] if @data.key? name.to_s
+      super
     end
 
-    def description=(description)
-      @description = description
-    end
+    private
 
-    def extra_metadata
-      @extra_metadata || {}
-    end
+    # Do basic validation and parsing of the name parameter.
+    def process_name(data)
+      validate_name(data['name'])
+      author, @module_name = data['name'].split(/[-\/]/, 2)
 
-    def extra_metadata=(extra_metadata)
-      @extra_metadata = extra_metadata
+      data['author'] ||= author if @data['author'] == DEFAULTS['author']
     end
 
-    def project_page
-      @project_page || 'UNKNOWN'
+    # Do basic validation on the version parameter.
+    def process_version(data)
+      validate_version(data['version'])
     end
 
-    def project_page=(project_page)
-      @project_page = project_page
-    end
+    # Do basic parsing of the source parameter.  If the source is hosted on
+    # GitHub, we can predict sensible defaults for both project_page and
+    # issues_url.
+    def process_source(data)
+      if data['source'] =~ %r[://]
+        source_uri = URI.parse(data['source'])
+      else
+        source_uri = URI.parse("http://#{data['source']}")
+      end
 
-    # Return an array of the module's Puppet types, each one is a hash
-    # containing :name and :doc.
-    def types
-      return @types ||= []
-    end
+      if source_uri.host =~ /^(www\.)?github\.com$/
+        source_uri.scheme = 'https'
+        source_uri.path.sub!(/\.git$/, '')
+        data['project_page'] ||= @data['project_page'] || source_uri.to_s
+        data['issues_url'] ||= @data['issues_url'] || source_uri.to_s.sub(/\/*$/, '') + '/issues'
+      end
 
-    # Return module's file checksums.
-    def checksums
-      return @checksums ||= {}
+    rescue URI::Error
+      return
     end
 
-    # Return the dashed name of the module, which may either be the
-    # dash-separated combination of the +username+ and module +name+, or just
-    # the module +name+.
-    def dashed_name
-      return [@username, @name].compact.join('-')
-    end
+    # Validates that the given module name is both namespaced and well-formed.
+    def validate_name(name)
+      return if name =~ /\A[a-z0-9]+[-\/][a-z][a-z0-9_]*\Z/i
 
-    # Return the release name, which is the combination of the +dashed_name+
-    # of the module and its +version+ number.
-    def release_name
-      return [dashed_name, @version].join('-')
-    end
+      namespace, modname = name.split(/[-\/]/, 2)
+      modname = :namespace_missing if namespace == ''
 
-    # Set the version of this module, ensure a string like '0.1.0' see the
-    # Semantic Versions here: http://semver.org
-    def version=(version)
-      if SemVer.valid?(version)
-        @version = version
+      err = case modname
+      when nil, '', :namespace_missing
+        "the field must be a namespaced module name"
+      when /[^a-z0-9_]/i
+        "the module name contains non-alphanumeric (or underscore) characters"
+      when /^[^a-z]/i
+        "the module name must begin with a letter"
       else
-        raise ArgumentError, "Invalid version format: #{@version} (Semantic Versions are acceptable: http://semver.org)"
+        "the namespace contains non-alphanumeric characters"
       end
-    end
 
-    def to_data_hash()
-      return extra_metadata.merge({
-        'name'         => @full_module_name,
-        'version'      => @version,
-        'source'       => source,
-        'author'       => author,
-        'license'      => license,
-        'summary'      => summary,
-        'description'  => description,
-        'project_page' => project_page,
-        'dependencies' => dependencies,
-        'types'        => types,
-        'checksums'    => checksums
-      })
+      raise ArgumentError, "Invalid 'name' field in metadata.json: #{err}"
     end
 
-    def to_hash()
-      to_data_hash
+    # Validates that the version string can be parsed as per SemVer.
+    def validate_version(version)
+      return if SemVer.valid?(version)
+
+      err = "version string cannot be parsed as a valid Semantic Version"
+      raise ArgumentError, "Invalid 'version' field in metadata.json: #{err}"
     end
   end
 end

data/lib/puppet/module_tool/modulefile.rb

@@ -30,49 +30,49 @@ module Puppet::ModuleTool
     # Set the +full_module_name+ (e.g. "myuser-mymodule"), which will also set the
     # +username+ and module +name+. Required.
     def name(name)
-      @metadata.full_module_name = name
+      @metadata.update('name' => name)
     end
 
     # Set the module +version+ (e.g., "0.1.0"). Required.
     def version(version)
-      @metadata.version = version
+      @metadata.update('version' => version)
     end
 
     # Add a dependency with the full_module_name +name+ (e.g. "myuser-mymodule"), an
     # optional +version_requirement+ (e.g. "0.1.0") and +repository+ (a URL
     # string). Optional. Can be called multiple times to add many dependencies.
     def dependency(name, version_requirement = nil, repository = nil)
-      @metadata.dependencies << Dependency.new(name, version_requirement, repository)
+      @metadata.to_hash['dependencies'] << Dependency.new(name, version_requirement, repository)
     end
 
     # Set the source
     def source(source)
-      @metadata.source = source
+      @metadata.update('source' => source)
     end
 
     # Set the author or default to +username+
     def author(author)
-        @metadata.author = author
+      @metadata.update('author' => author)
     end
 
     # Set the license
     def license(license)
-      @metadata.license = license
+      @metadata.update('license' => license)
     end
 
     # Set the summary
     def summary(summary)
-      @metadata.summary = summary
+      @metadata.update('summary' => summary)
     end
 
     # Set the description
     def description(description)
-      @metadata.description = description
+      @metadata.update('description' => description)
     end
 
     # Set the project page
     def project_page(project_page)
-      @metadata.project_page = project_page
+      @metadata.update('project_page' => project_page)
     end
   end
 end

data/lib/puppet/module_tool/shared_behaviors.rb

@@ -1,8 +1,3 @@
-require 'open-uri'
-
-require 'puppet/module_tool'
-require 'puppet/module_tool/errors'
-
 module Puppet::ModuleTool::Shared
 
   include Puppet::ModuleTool::Errors
@@ -80,7 +75,7 @@ module Puppet::ModuleTool::Shared
         :queued     => true
       }
 
-      if @force
+      if forced?
         range = SemVer[@version] rescue SemVer['>= 0.0.0']
       else
         range = (@conditions[mod]).map do |r|
@@ -101,7 +96,7 @@ module Puppet::ModuleTool::Shared
           :conditions        => @conditions
       end
 
-      if !(@force || @installed[mod].empty? || source.last[:name] == :you)
+      if !(forced? || @installed[mod].empty? || source.last[:name] == :you)
         next if range === SemVer.new(@installed[mod].first.version)
         action = :upgrade
       elsif @installed[mod].empty?
@@ -165,4 +160,21 @@ module Puppet::ModuleTool::Shared
       ]
     end.flatten
   end
+
+  def forced?
+    options[:force]
+  end
+
+  def add_module_name_constraints_to_graph(graph)
+    # Puppet modules are installed by "module name", but resolved by
+    # "full name" (including namespace).  So that we don't run into
+    # problems at install time, we should reject any solution that
+    # depends on multiple nodes with the same "module name".
+    graph.add_graph_constraint('PMT') do |nodes|
+      names = nodes.map { |x| x.dependency_names + [ x.name ] }.flatten
+      names = names.map { |x| x.tr('/', '-') }.uniq
+      names = names.map { |x| x[/-(.*)/, 1] }
+      names.length == names.uniq.length
+    end
+  end
 end