puppet-retrospec 1.5.0 → 1.6.0

data/vendor/pup410/lib/puppet/module_tool.rb

@@ -0,0 +1,192 @@
+# encoding: UTF-8
+# Load standard libraries
+require 'pathname'
+require 'fileutils'
+require 'puppet/util/colors'
+
+module Puppet
+  module ModuleTool
+    require 'puppet/module_tool/tar'
+    extend Puppet::Util::Colors
+
+    # Directory and names that should not be checksummed.
+    ARTIFACTS = ['pkg', /^\./, /^~/, /^#/, 'coverage', 'checksums.json', 'REVISION']
+    FULL_MODULE_NAME_PATTERN = /\A([^-\/|.]+)[-|\/](.+)\z/
+    REPOSITORY_URL = Puppet.settings[:module_repository]
+
+    # Is this a directory that shouldn't be checksummed?
+    #
+    # TODO: Should this be part of Checksums?
+    # TODO: Rename this method to reflect its purpose?
+    # TODO: Shouldn't this be used when building packages too?
+    def self.artifact?(path)
+      case File.basename(path)
+      when *ARTIFACTS
+        true
+      else
+        false
+      end
+    end
+
+    # Return the +username+ and +modname+ for a given +full_module_name+, or raise an
+    # ArgumentError if the argument isn't parseable.
+    def self.username_and_modname_from(full_module_name)
+      if matcher = full_module_name.match(FULL_MODULE_NAME_PATTERN)
+        return matcher.captures
+      else
+        raise ArgumentError, "Not a valid full name: #{full_module_name}"
+      end
+    end
+
+    # Find the module root when given a path by checking each directory up from
+    # its current location until it finds one that satisfies is_module_root?
+    #
+    # @param path [Pathname, String] path to start from
+    # @return [Pathname, nil] the root path of the module directory or nil if
+    #   we cannot find one
+    def self.find_module_root(path)
+      path = Pathname.new(path) if path.class == String
+
+      path.expand_path.ascend do |p|
+        return p if is_module_root?(p)
+      end
+
+      nil
+    end
+
+    # Analyse path to see if it is a module root directory by detecting a
+    # file named 'metadata.json'
+    #
+    # @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 + 'metadata.json')
+    end
+
+    # Builds a formatted tree from a list of node hashes containing +:text+
+    # and +:dependencies+ keys.
+    def self.format_tree(nodes, level = 0)
+      str = ''
+      nodes.each_with_index do |node, i|
+        last_node = nodes.length - 1 == i
+        deps = node[:dependencies] || []
+
+        str << (indent = "  " * level)
+        str << (last_node ? "└" : "├")
+        str << "─"
+        str << (deps.empty? ? "─" : "┬")
+        str << " #{node[:text]}\n"
+
+        branch = format_tree(deps, level + 1)
+        branch.gsub!(/^#{indent} /, indent + '│') unless last_node
+        str << branch
+      end
+
+      return str
+    end
+
+    def self.build_tree(mods, dir)
+      mods.each do |mod|
+        version_string = mod[:version].to_s.sub(/^(?!v)/, 'v')
+
+        if mod[:action] == :upgrade
+          previous_version = mod[:previous_version].to_s.sub(/^(?!v)/, 'v')
+          version_string = "#{previous_version} -> #{version_string}"
+        end
+
+        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
+
+    # @param options [Hash<Symbol,String>] This hash will contain any
+    #   command-line arguments that are not Settings, as those will have already
+    #   been extracted by the underlying application code.
+    #
+    # @note Unfortunately the whole point of this method is the side effect of
+    # 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 = environment_from_options(options)
+
+      modulepath = [options[:target_dir]] + current_environment.full_modulepath
+
+      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 supersede 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]
+        # This use of looking up an environment is correct since it honours
+        # a request to get a particular environment via environment name.
+        Puppet.lookup(:environments).get!(options[:environment])
+      else
+        Puppet.lookup(:current_environment)
+      end
+    end
+
+    # Handles parsing of module dependency expressions into proper
+    # {SemanticPuppet::VersionRange}s, including reasonable error handling.
+    #
+    # @param where [String] a description of the thing we're parsing the
+    #        dependency expression for
+    # @param dep [Hash] the dependency description to parse
+    # @return [Array(String, SemanticPuppet::VersionRange, String)] a tuple of the
+    #         dependent module's name, the version range dependency, and the
+    #         unparsed range expression.
+    def self.parse_module_dependency(where, dep)
+      dep_name = dep['name'].tr('/', '-')
+      range = dep['version_requirement'] || '>= 0.0.0'
+
+      begin
+        parsed_range = SemanticPuppet::VersionRange.parse(range)
+      rescue ArgumentError => e
+        Puppet.debug "Error in #{where} parsing dependency #{dep_name} (#{e.message}); using empty range."
+        parsed_range = SemanticPuppet::VersionRange::EMPTY_RANGE
+      end
+
+      [ dep_name, parsed_range, range ]
+    end
+  end
+end
+
+# Load remaining libraries
+require 'puppet/module_tool/errors'
+require 'puppet/module_tool/applications'
+require 'puppet/module_tool/checksums'
+require 'puppet/module_tool/contents_description'
+require 'puppet/module_tool/dependency'
+require 'puppet/module_tool/metadata'
+require 'puppet/forge/cache'
+require 'puppet/forge'

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

@@ -0,0 +1,149 @@
+require 'fileutils'
+require 'json'
+require 'puppet/file_system'
+require 'pathspec'
+
+module Puppet::ModuleTool
+  module Applications
+    class Builder < Application
+
+      def initialize(path, options = {})
+        @path = File.expand_path(path)
+        @pkg_path = File.join(@path, 'pkg')
+        super(options)
+      end
+
+      def run
+        load_metadata!
+        create_directory
+        copy_contents
+        write_json
+        Puppet.notice "Building #{@path} for release"
+        pack
+        relative = Pathname.new(archive_file).relative_path_from(Pathname.new(File.expand_path(Dir.pwd)))
+
+        # Return the Pathname object representing the path to the release
+        # archive just created. This return value is used by the module_tool
+        # face build action, and displayed to on the console using the to_s
+        # method.
+        #
+        # Example return value:
+        #
+        #   <Pathname:puppetlabs-apache/pkg/puppetlabs-apache-0.0.1.tar.gz>
+        #
+        relative
+      end
+
+      private
+
+      def archive_file
+        File.join(@pkg_path, "#{metadata.release_name}.tar.gz")
+      end
+
+      def pack
+        FileUtils.rm archive_file rescue nil
+
+        tar = Puppet::ModuleTool::Tar.instance
+        Dir.chdir(@pkg_path) do
+          tar.pack(metadata.release_name, archive_file)
+        end
+      end
+
+      def create_directory
+        FileUtils.mkdir(@pkg_path) rescue nil
+        if File.directory?(build_path)
+          FileUtils.rm_rf(build_path, :secure => true)
+        end
+        FileUtils.mkdir(build_path)
+      end
+
+      def ignored_files
+        if @ignored_files
+          return @ignored_files
+        else
+          pmtignore = File.join(@path, '.pmtignore')
+          gitignore = File.join(@path, '.gitignore')
+
+          if File.file? pmtignore
+            @ignored_files = PathSpec.new Puppet::FileSystem.read(pmtignore, :encoding => 'utf-8')
+          elsif File.file? gitignore
+            @ignored_files = PathSpec.new Puppet::FileSystem.read(gitignore, :encoding => 'utf-8')
+          else
+            @ignored_files = PathSpec.new
+          end
+        end
+      end
+
+      def copy_contents
+        symlinks = []
+        Find.find(File.join(@path)) do |path|
+          # because Find.find finds the path itself
+          if path == @path
+            next
+          end
+
+          # Needed because pathspec looks for a trailing slash in the path to
+          # determine if a path is a directory
+          path = path.to_s + '/' if File.directory? path
+
+          # if it matches, then prune it with fire
+          unless ignored_files.match_paths([path], @path).empty?
+            Find.prune
+          end
+
+          # don't copy all the Puppet ARTIFACTS
+          rel = Pathname.new(path).relative_path_from(Pathname.new(@path))
+          case rel.to_s
+          when *Puppet::ModuleTool::ARTIFACTS
+            Find.prune
+          end
+
+          # make dir tree, copy files, and add symlinks to the symlinks list
+          dest = "#{build_path}/#{rel.to_s}"
+          if File.directory? path
+            FileUtils.mkdir dest, :mode => File.stat(path).mode
+          elsif Puppet::FileSystem.symlink? path
+            symlinks << path
+          else
+            FileUtils.cp path, dest, :preserve => true
+          end
+        end
+
+        # send a message about each symlink and raise an error if they exist
+        unless symlinks.empty?
+          symlinks.each do |s|
+            s = Pathname.new s
+            mpath = Pathname.new @path
+            Puppet.warning "Symlinks in modules are unsupported. Please investigate symlink #{s.relative_path_from mpath} -> #{s.realpath.relative_path_from mpath}."
+          end
+
+          raise Puppet::ModuleTool::Errors::ModuleToolError, "Found symlinks. Symlinks in modules are not allowed, please remove them."
+        end
+      end
+
+      def write_json
+        metadata_path = File.join(build_path, 'metadata.json')
+
+        if metadata.to_hash.include? 'checksums'
+          Puppet.warning "A 'checksums' field was found in metadata.json. This field will be ignored and can safely be removed."
+        end
+
+        # TODO: This may necessarily change the order in which the metadata.json
+        # file is packaged from what was written by the user.  This is a
+        # regretable, but required for now.
+        Puppet::FileSystem.open(metadata_path, nil, 'w:UTF-8') do |f|
+          f.write(metadata.to_json)
+        end
+
+        # PSON.pretty_generate is a BINARY string
+        Puppet::FileSystem.open(File.join(build_path, 'checksums.json'), nil, 'wb') do |f|
+          f.write(PSON.pretty_generate(Checksums.new(build_path)))
+        end
+      end
+
+      def build_path
+        @build_path ||= File.join(@pkg_path, metadata.release_name)
+      end
+    end
+  end
+end

data/vendor/pup410/lib/puppet/module_tool/applications/installer.rb

@@ -0,0 +1,351 @@
+require 'open-uri'
+require 'pathname'
+require 'fileutils'
+require 'tmpdir'
+
+require 'puppet/forge'
+require 'puppet/module_tool'
+require 'puppet/module_tool/shared_behaviors'
+require 'puppet/module_tool/install_directory'
+require 'puppet/module_tool/local_tarball'
+require 'puppet/module_tool/installed_modules'
+
+module Puppet::ModuleTool
+  module Applications
+    class Installer < Application
+
+      include Puppet::ModuleTool::Errors
+      include Puppet::Forge::Errors
+
+      def initialize(name, install_dir, options = {})
+        super(options)
+
+        @action              = :install
+        @environment         = options[:environment_instance]
+        @ignore_dependencies = forced? || options[:ignore_dependencies]
+        @name                = name
+        @install_dir         = install_dir
+
+        Puppet::Forge::Cache.clean
+
+        @local_tarball = Puppet::FileSystem.exist?(name)
+
+        if @local_tarball
+          release = local_tarball_source.release
+          @name = release.name
+          options[:version] = release.version.to_s
+          SemanticPuppet::Dependency.add_source(local_tarball_source)
+
+          # If we're operating on a local tarball and ignoring dependencies, we
+          # don't need to search any additional sources.  This will cut down on
+          # unnecessary network traffic.
+          unless @ignore_dependencies
+            SemanticPuppet::Dependency.add_source(installed_modules_source)
+            SemanticPuppet::Dependency.add_source(module_repository)
+          end
+
+        else
+          SemanticPuppet::Dependency.add_source(installed_modules_source) unless forced?
+          SemanticPuppet::Dependency.add_source(module_repository)
+        end
+      end
+
+      def run
+        name = @name.tr('/', '-')
+        version = options[:version] || '>= 0.0.0'
+
+        results = { :action => :install, :module_name => name, :module_version => version }
+
+        begin
+          if installed_module = installed_modules[name]
+            unless forced?
+              if SemanticPuppet::VersionRange.parse(version).include? installed_module.version
+                results[:result] = :noop
+                results[:version] = installed_module.version
+                return results
+              else
+                changes = Checksummer.run(installed_modules[name].mod.path) rescue []
+                raise AlreadyInstalledError,
+                  :module_name       => name,
+                  :installed_version => installed_modules[name].version,
+                  :requested_version => options[:version] || :latest,
+                  :local_changes     => changes
+              end
+            end
+          end
+
+          @install_dir.prepare(name, options[:version] || 'latest')
+          results[:install_dir] = @install_dir.target
+
+          unless @local_tarball && @ignore_dependencies
+            Puppet.notice "Downloading from #{module_repository.host} ..."
+          end
+
+          if @ignore_dependencies
+            graph = build_single_module_graph(name, version)
+          else
+            graph = build_dependency_graph(name, version)
+          end
+
+          unless forced?
+            add_module_name_constraints_to_graph(graph)
+          end
+
+          installed_modules.each do |mod, release|
+            mod = mod.tr('/', '-')
+            next if mod == name
+
+            version = release.version
+
+            unless forced?
+              # Since upgrading already installed modules can be troublesome,
+              # we'll place constraints on the graph for each installed module,
+              # locking it to upgrades within the same major version.
+              installed_range = ">=#{version} #{version.major}.x"
+              graph.add_constraint('installed', mod, installed_range) do |node|
+                SemanticPuppet::VersionRange.parse(installed_range).include? node.version
+              end
+
+              release.mod.dependencies.each do |dep|
+                dep_name = dep['name'].tr('/', '-')
+
+                range = dep['version_requirement']
+                graph.add_constraint("#{mod} constraint", dep_name, range) do |node|
+                  SemanticPuppet::VersionRange.parse(range).include? node.version
+                end
+              end
+            end
+          end
+
+          # Ensure that there is at least one candidate release available
+          # for the target package.
+          if graph.dependencies[name].empty?
+            raise NoCandidateReleasesError, results.merge(:module_name => name, :source => module_repository.host, :requested_version => options[:version] || :latest)
+          end
+
+          begin
+            Puppet.info "Resolving dependencies ..."
+            releases = SemanticPuppet::Dependency.resolve(graph)
+          rescue SemanticPuppet::Dependency::UnsatisfiableGraph
+            raise NoVersionsSatisfyError, results.merge(:requested_name => name)
+          end
+
+          unless forced?
+            # Check for module name conflicts.
+            releases.each do |rel|
+              if installed_module = installed_modules_source.by_name[rel.name.split('-').last]
+                next if installed_module.has_metadata? && installed_module.forge_name.tr('/', '-') == rel.name
+
+                if rel.name != name
+                  dependency = {
+                    :name => rel.name,
+                    :version => rel.version
+                  }
+                end
+
+                raise InstallConflictError,
+                  :requested_module  => name,
+                  :requested_version => options[:version] || 'latest',
+                  :dependency        => dependency,
+                  :directory         => installed_module.path,
+                  :metadata          => installed_module.metadata
+              end
+            end
+          end
+
+          Puppet.info "Preparing to install ..."
+          releases.each { |release| release.prepare }
+
+          Puppet.notice 'Installing -- do not interrupt ...'
+          releases.each do |release|
+            installed = installed_modules[release.name]
+            if forced? || installed.nil?
+              release.install(Pathname.new(results[:install_dir]))
+            else
+              release.install(Pathname.new(installed.mod.modulepath))
+            end
+          end
+
+          results[:result] = :success
+          results[:installed_modules] = releases
+          results[:graph] = [ build_install_graph(releases.first, releases) ]
+
+        rescue ModuleToolError, ForgeError => err
+          results[:error] = {
+            :oneline   => err.message,
+            :multiline => err.multiline,
+          }
+        ensure
+          results[:result] ||= :failure
+        end
+
+        results
+      end
+
+      private
+
+      def module_repository
+        @repo ||= Puppet::Forge.new
+      end
+
+      def local_tarball_source
+        @tarball_source ||= begin
+          Puppet::ModuleTool::LocalTarball.new(@name)
+        rescue Puppet::Module::Error => e
+          raise InvalidModuleError.new(@name, :action => @action, :error  => e)
+        end
+      end
+
+      def installed_modules_source
+        @installed ||= Puppet::ModuleTool::InstalledModules.new(@environment)
+      end
+
+      def installed_modules
+        installed_modules_source.modules
+      end
+
+      def build_single_module_graph(name, version)
+        range = SemanticPuppet::VersionRange.parse(version)
+        graph = SemanticPuppet::Dependency::Graph.new(name => range)
+        releases = SemanticPuppet::Dependency.fetch_releases(name)
+        releases.each { |release| release.dependencies.clear }
+        graph << releases
+      end
+
+      def build_dependency_graph(name, version)
+        SemanticPuppet::Dependency.query(name => version)
+      end
+
+      def build_install_graph(release, installed, graphed = [])
+        graphed << release
+        dependencies = release.dependencies.values.map do |deps|
+          dep = (deps & installed).first
+          unless dep.nil? || graphed.include?(dep)
+            build_install_graph(dep, installed, graphed)
+          end
+        end
+
+        previous = installed_modules[release.name]
+        previous = previous.version if previous
+        return {
+          :release          => release,
+          :name             => release.name,
+          :path             => release.install_dir.to_s,
+          :dependencies     => dependencies.compact,
+          :version          => release.version,
+          :previous_version => previous,
+          :action           => (previous.nil? || previous == release.version || forced? ? :install : :upgrade),
+        }
+      end
+
+      include Puppet::ModuleTool::Shared
+
+      # Return a Pathname object representing the path to the module
+      # release package in the `Puppet.settings[:module_working_dir]`.
+      def get_release_packages
+        get_local_constraints
+
+        if !forced? && @installed.include?(@module_name)
+          raise AlreadyInstalledError,
+            :module_name       => @module_name,
+            :installed_version => @installed[@module_name].first.version,
+            :requested_version => @version || (@conditions[@module_name].empty? ? :latest : :best),
+            :local_changes     => Puppet::ModuleTool::Applications::Checksummer.run(@installed[@module_name].first.path)
+        end
+
+        if @ignore_dependencies && @source == :filesystem
+          @urls   = {}
+          @remote = { "#{@module_name}@#{@version}" => { } }
+          @versions = {
+            @module_name => [
+              { :vstring => @version, :semver => SemVer.new(@version) }
+            ]
+          }
+        else
+          get_remote_constraints(@forge)
+        end
+
+        @graph = resolve_constraints({ @module_name => @version })
+        @graph.first[:tarball] = @filename if @source == :filesystem
+        resolve_install_conflicts(@graph) unless forced?
+
+        # This clean call means we never "cache" the module we're installing, but this
+        # is desired since module authors can easily rerelease modules different content but the same
+        # version number, meaning someone with the old content cached will be very confused as to why
+        # they can't get new content.
+        # Long term we should just get rid of this caching behavior and cleanup downloaded modules after they install
+        # but for now this is a quick fix to disable caching
+        Puppet::Forge::Cache.clean
+        download_tarballs(@graph, @graph.last[:path], @forge)
+      end
+
+      #
+      # Resolve installation conflicts by checking if the requested module
+      # or one of its dependencies conflicts with an installed module.
+      #
+      # Conflicts occur under the following conditions:
+      #
+      # When installing 'puppetlabs-foo' and an existing directory in the
+      # target install path contains a 'foo' directory and we cannot determine
+      # the "full name" of the installed module.
+      #
+      # When installing 'puppetlabs-foo' and 'pete-foo' is already installed.
+      # This is considered a conflict because 'puppetlabs-foo' and 'pete-foo'
+      # install into the same directory 'foo'.
+      #
+      def resolve_install_conflicts(graph, is_dependency = false)
+        Puppet.debug("Resolving conflicts for #{graph.map {|n| n[:module]}.join(',')}")
+
+        graph.each do |release|
+          @environment.modules_by_path[options[:target_dir]].each do |mod|
+            if mod.has_metadata?
+              metadata = {
+                :name    => mod.forge_name.gsub('/', '-'),
+                :version => mod.version
+              }
+              next if release[:module] == metadata[:name]
+            else
+              metadata = nil
+            end
+
+            if release[:module] =~ /-#{mod.name}$/
+              dependency_info = {
+                :name    => release[:module],
+                :version => release[:version][:vstring]
+              }
+              dependency = is_dependency ? dependency_info : nil
+              all_versions = @versions["#{@module_name}"].sort_by { |h| h[:semver] }
+              versions = all_versions.select { |x| x[:semver].special == '' }
+              versions = all_versions if versions.empty?
+              latest_version = versions.last[:vstring]
+
+              raise InstallConflictError,
+                :requested_module  => @module_name,
+                :requested_version => @version || "latest: v#{latest_version}",
+                :dependency        => dependency,
+                :directory         => mod.path,
+                :metadata          => metadata
+            end
+          end
+
+          deps = release[:dependencies]
+          if deps && !deps.empty?
+            resolve_install_conflicts(deps, true)
+          end
+        end
+      end
+
+      #
+      # Check if a file is a vaild module package.
+      # ---
+      # FIXME: Checking for a valid module package should be more robust and
+      # use the actual metadata contained in the package. 03132012 - Hightower
+      # +++
+      #
+      def is_module_package?(name)
+        filename = File.expand_path(name)
+        filename =~ /.tar.gz$/
+      end
+    end
+  end
+end