bolt 0.19.1 → 0.20.0

data/vendored/puppet/lib/puppet/module_tool/applications/unpacker.rb

@@ -1,100 +0,0 @@
-require 'pathname'
-require 'tmpdir'
-require 'json'
-require 'puppet/file_system'
-
-module Puppet::ModuleTool
-  module Applications
-    class Unpacker < Application
-      def self.unpack(filename, target)
-        app = self.new(filename, :target_dir => target)
-        app.unpack
-        app.sanity_check
-        app.move_into(target)
-      end
-
-      def self.harmonize_ownership(source, target)
-        unless Puppet.features.microsoft_windows?
-          source = Pathname.new(source) unless source.respond_to?(:stat)
-          target = Pathname.new(target) unless target.respond_to?(:stat)
-
-          FileUtils.chown_R(source.stat.uid, source.stat.gid, target)
-        end
-      end
-
-      def initialize(filename, options = {})
-        @filename = Pathname.new(filename)
-        super(options)
-        @module_path = Pathname(options[:target_dir])
-      end
-
-      def run
-        unpack
-        sanity_check
-        module_dir = @module_path + module_name
-        move_into(module_dir)
-
-        # Return the Pathname object representing the directory where the
-        # module release archive was unpacked the to.
-        return module_dir
-      end
-
-      # @api private
-      # Error on symlinks and other junk
-      def sanity_check
-        symlinks = Dir.glob("#{tmpdir}/**/*", File::FNM_DOTMATCH).map { |f| Pathname.new(f) }.select {|p| Puppet::FileSystem.symlink? p}
-        tmpdirpath = Pathname.new tmpdir
-
-        symlinks.each do |s|
-          Puppet.warning _("Symlinks in modules are unsupported. Please investigate symlink %{from}->%{to}.") % { from: s.relative_path_from(tmpdirpath), to: Puppet::FileSystem.readlink(s) }
-        end
-      end
-
-      # @api private
-      def unpack
-        begin
-          Puppet::ModuleTool::Tar.instance.unpack(@filename.to_s, tmpdir, [@module_path.stat.uid, @module_path.stat.gid].join(':'))
-        rescue Puppet::ExecutionFailure => e
-          raise RuntimeError, _("Could not extract contents of module archive: %{message}") % { message: e.message }
-        end
-      end
-
-      # @api private
-      def root_dir
-        return @root_dir if @root_dir
-
-        # Grab the first directory containing a metadata.json file
-        metadata_file = Dir["#{tmpdir}/**/metadata.json"].sort_by(&:length)[0]
-
-        if metadata_file
-          @root_dir = Pathname.new(metadata_file).dirname
-        else
-          raise _("No valid metadata.json found!")
-        end
-      end
-
-      # @api private
-      def module_name
-        metadata = JSON.parse((root_dir + 'metadata.json').read)
-        metadata['name'][/-(.*)/, 1]
-      end
-
-      # @api private
-      def move_into(dir)
-        dir = Pathname.new(dir)
-        dir.rmtree if dir.exist?
-        FileUtils.mv(root_dir, dir)
-      ensure
-        FileUtils.rmtree(tmpdir)
-      end
-
-      # Obtain a suitable temporary path for unpacking tarballs
-      #
-      # @api private
-      # @return [String] path to temporary unpacking location
-      def tmpdir
-        @dir ||= Dir.mktmpdir('tmp', Puppet::Forge::Cache.base_path)
-      end
-    end
-  end
-end

data/vendored/puppet/lib/puppet/module_tool/applications/upgrader.rb

@@ -1,281 +0,0 @@
-require 'pathname'
-
-require 'puppet/forge'
-require 'puppet/module_tool'
-require 'puppet/module_tool/shared_behaviors'
-require 'puppet/module_tool/install_directory'
-require 'puppet/module_tool/installed_modules'
-
-module Puppet::ModuleTool
-  module Applications
-    class Upgrader < Application
-
-      include Puppet::ModuleTool::Errors
-
-      def initialize(name, options)
-        super(options)
-
-        @action              = :upgrade
-        @environment         = options[:environment_instance]
-        @name                = name
-        @ignore_changes      = forced? || options[:ignore_changes]
-        @ignore_dependencies = forced? || options[:ignore_dependencies]
-        @strict_semver       = !!options[:strict_semver]
-
-        SemanticPuppet::Dependency.add_source(installed_modules_source)
-        SemanticPuppet::Dependency.add_source(module_repository)
-      end
-
-      def run
-        # Disallow anything that invokes md5 to avoid un-friendly termination due to FIPS
-        raise _("Module upgrade is prohibited in FIPS mode.") if Facter.value(:fips_enabled)
-
-        name = @name.tr('/', '-')
-        version = options[:version] || '>= 0.0.0'
-
-        results = {
-          :action => :upgrade,
-          :requested_version => options[:version] || :latest,
-        }
-
-        begin
-          all_modules = @environment.modules_by_path.values.flatten
-          matching_modules = all_modules.select do |x|
-            x.forge_name && x.forge_name.tr('/', '-') == name
-          end
-
-          if matching_modules.empty?
-            raise NotInstalledError, results.merge(:module_name => name)
-          elsif matching_modules.length > 1
-            raise MultipleInstalledError, results.merge(:module_name => name, :installed_modules => matching_modules)
-          end
-
-          installed_release = installed_modules[name]
-
-          # `priority` is an attribute of a `SemanticPuppet::Dependency::Source`,
-          # which is delegated through `ModuleRelease` instances for the sake of
-          # comparison (sorting). By default, the `InstalledModules` source has
-          # a priority of 10 (making it the most preferable source, so that
-          # already installed versions of modules are selected in preference to
-          # modules from e.g. the Forge). Since we are specifically looking to
-          # upgrade this module, we don't want the installed version of this
-          # module to be chosen in preference to those with higher versions.
-          #
-          # This implementation is suboptimal, and since we can expect this sort
-          # of behavior to be reasonably common in Semantic, we should probably
-          # see about implementing a `ModuleRelease#override_priority` method
-          # (or something similar).
-          def installed_release.priority
-            0
-          end
-
-          mod = installed_release.mod
-          results[:installed_version] = SemanticPuppet::Version.parse(mod.version)
-          dir = Pathname.new(mod.modulepath)
-
-          vstring = mod.version ? "v#{mod.version}" : '???'
-          Puppet.notice _("Found '%{name}' (%{version}) in %{dir} ...") % { name: name, version: colorize(:cyan, vstring), dir: dir }
-          unless @ignore_changes
-            changes = Checksummer.run(mod.path) rescue []
-            if mod.has_metadata? && !changes.empty?
-              raise LocalChangesError,
-                :action            => :upgrade,
-                :module_name       => name,
-                :requested_version => results[:requested_version],
-                :installed_version => mod.version
-            end
-          end
-
-          Puppet::Forge::Cache.clean
-
-          # Ensure that there is at least one candidate release available
-          # for the target package.
-          available_versions = module_repository.fetch(name)
-          if available_versions.empty?
-            raise NoCandidateReleasesError, results.merge(:module_name => name, :source => module_repository.host)
-          elsif results[:requested_version] != :latest
-            requested = Puppet::Module.parse_range(results[:requested_version], @strict_semver)
-            unless available_versions.any? {|m| requested.include? m.version}
-              raise NoCandidateReleasesError, results.merge(:module_name => name, :source => module_repository.host)
-            end
-          end
-
-          Puppet.notice _("Downloading from %{host} ...") % { host: module_repository.host }
-          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 |installed_module, release|
-            installed_module = installed_module.tr('/', '-')
-            next if installed_module == 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', installed_module, installed_range) do |node|
-                Puppet::Module.parse_range(installed_range, @strict_semver).include? node.version
-              end
-
-              release.mod.dependencies.each do |dep|
-                dep_name = dep['name'].tr('/', '-')
-
-                range = dep['version_requirement']
-                graph.add_constraint("#{installed_module} constraint", dep_name, range) do |node|
-                  Puppet::Module.parse_range(range, @strict_semver).include? node.version
-                end
-              end
-            end
-          end
-
-          begin
-            Puppet.info _("Resolving dependencies ...")
-            releases = SemanticPuppet::Dependency.resolve(graph)
-          rescue SemanticPuppet::Dependency::UnsatisfiableGraph
-            raise NoVersionsSatisfyError, results.merge(:requested_name => name)
-          end
-
-          releases.each do |rel|
-            if mod = installed_modules_source.by_name[rel.name.split('-').last]
-              next if mod.has_metadata? && mod.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         => mod.path,
-                :metadata          => mod.metadata
-            end
-          end
-
-          child = releases.find { |x| x.name == name }
-
-          unless forced?
-            if child.version == results[:installed_version]
-              versions = graph.dependencies[name].map { |r| r.version }
-              newer_versions = versions.select { |v| v > results[:installed_version] }
-
-              raise VersionAlreadyInstalledError,
-                :module_name       => name,
-                :requested_version => results[:requested_version],
-                :installed_version => results[:installed_version],
-                :newer_versions    => newer_versions,
-                :possible_culprits => installed_modules_source.fetched.reject { |x| x == name }
-            elsif child.version < results[:installed_version]
-              raise DowngradingUnsupportedError,
-                :module_name       => name,
-                :requested_version => results[:requested_version],
-                :installed_version => results[:installed_version]
-            end
-          end
-
-          Puppet.info _("Preparing to upgrade ...")
-          releases.each { |release| release.prepare }
-
-          Puppet.notice _('Upgrading -- do not interrupt ...')
-          releases.each do |release|
-            if installed = installed_modules[release.name]
-              release.install(Pathname.new(installed.mod.modulepath))
-            else
-              release.install(dir)
-            end
-          end
-
-          results[:result] = :success
-          results[:base_dir] = releases.first.install_dir
-          results[:affected_modules] = releases
-          results[:graph] = [ build_install_graph(releases.first, releases) ]
-
-        rescue VersionAlreadyInstalledError => e
-          results[:result] = (e.newer_versions.empty? ? :noop : :failure)
-          results[:error] = { :oneline => e.message, :multiline => e.multiline }
-        rescue => e
-          results[:error] = {
-            :oneline   => e.message,
-            :multiline => e.respond_to?(:multiline) ? e.multiline : [e.to_s, e.backtrace].join("\n")
-          }
-        ensure
-          results[:result] ||= :failure
-        end
-
-        results
-      end
-
-      private
-      def module_repository
-        @repo ||= Puppet::Forge.new(Puppet[:module_repository], @strict_semver)
-      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 = Puppet::Module.parse_range(version, @strict_semver)
-        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 = [])
-        previous = installed_modules[release.name]
-        previous = previous.version if previous
-
-        action = :upgrade
-        unless previous && previous != release.version
-          action = :install
-        end
-
-        graphed << release
-
-        dependencies = release.dependencies.values.map do |deps|
-          dep = (deps & installed).first
-          if dep == installed_modules[dep.name]
-            next
-          end
-
-          if dep && !graphed.include?(dep)
-            build_install_graph(dep, installed, graphed)
-          end
-        end.compact
-
-        return {
-          :release          => release,
-          :name             => release.name,
-          :path             => release.install_dir,
-          :dependencies     => dependencies.compact,
-          :version          => release.version,
-          :previous_version => previous,
-          :action           => action,
-        }
-      end
-
-      include Puppet::ModuleTool::Shared
-    end
-  end
-end

data/vendored/puppet/lib/puppet/module_tool/checksums.rb

@@ -1,49 +0,0 @@
-require 'digest/md5'
-require 'puppet/network/format_support'
-
-module Puppet::ModuleTool
-
-  # = Checksums
-  #
-  # This class provides methods for generating checksums for data and adding
-  # them to +Metadata+.
-  class Checksums
-    include Puppet::Network::FormatSupport
-    include Enumerable
-
-    # Instantiate object with string +path+ to create checksums from.
-    def initialize(path)
-      @path = Pathname.new(path)
-    end
-
-    # Return checksum for the +Pathname+.
-    def checksum(pathname)
-      return Digest::MD5.hexdigest(Puppet::FileSystem.binread(pathname))
-    end
-
-    # Return checksums for object's +Pathname+, generate if it's needed.
-    # Result is a hash of path strings to checksum strings.
-    def data
-      unless @data
-        @data = {}
-        @path.find do |descendant|
-          if Puppet::ModuleTool.artifact?(descendant)
-            Find.prune
-          elsif descendant.file?
-            path = descendant.relative_path_from(@path)
-            @data[path.to_s] = checksum(descendant)
-          end
-        end
-      end
-      return @data
-    end
-
-    alias :to_data_hash :data
-    alias :to_hash :data
-
-    # TODO: Why?
-    def each(&block)
-      data.each(&block)
-    end
-  end
-end

data/vendored/puppet/lib/puppet/module_tool/contents_description.rb

@@ -1,88 +0,0 @@
-require 'puppet/module_tool'
-
-module Puppet::ModuleTool
-
-  # = ContentsDescription
-  #
-  # This class populates +Metadata+'s Puppet type information.
-  class ContentsDescription
-
-    # Instantiate object for string +module_path+.
-    def initialize(module_path)
-      @module_path = module_path
-    end
-
-    # Update +Metadata+'s Puppet type information.
-    def annotate(metadata)
-      metadata.types.replace data.clone
-    end
-
-    # Return types for this module. Result is an array of hashes, each of which
-    # describes a Puppet type. The type description hash structure is:
-    # * :name => Name of this Puppet type.
-    # * :doc => Documentation for this type.
-    # * :properties => Array of hashes representing the type's properties, each
-    #   containing :name and :doc.
-    # * :parameters => Array of hashes representing the type's parameters, each
-    #   containing :name and :doc.
-    # * :providers => Array of hashes representing the types providers, each
-    #   containing :name and :doc.
-    # TODO Write a TypeDescription to encapsulate these structures and logic?
-    def data
-      unless @data
-        @data = []
-        type_names = []
-        for module_filename in Dir[File.join(@module_path, "lib/puppet/type/*.rb")]
-          require module_filename
-          type_name = File.basename(module_filename, ".rb")
-          type_names << type_name
-
-          for provider_filename in Dir[File.join(@module_path, "lib/puppet/provider/#{type_name}/*.rb")]
-            require provider_filename
-          end
-        end
-
-        type_names.each do |name|
-          if type = Puppet::Type.type(name.to_sym)
-            type_hash = {:name => name, :doc => type.doc}
-            type_hash[:properties] = attr_doc(type, :property)
-            type_hash[:parameters] = attr_doc(type, :param)
-            if type.providers.size > 0
-              type_hash[:providers] = provider_doc(type)
-            end
-            @data << type_hash
-          else
-            Puppet.warning _("Could not find/load type: %{name}") % { name: name }
-          end
-        end
-      end
-      @data
-    end
-
-    # Return an array of hashes representing this +type+'s attrs of +kind+
-    # (e.g. :param or :property), each containing :name and :doc.
-    def attr_doc(type, kind)
-      attrs = []
-
-      type.allattrs.each do |name|
-        if type.attrtype(name) == kind && name != :provider
-          attrs.push(:name => name, :doc => type.attrclass(name).doc)
-        end
-      end
-
-      attrs
-    end
-
-    # Return an array of hashes representing this +type+'s providers, each
-    # containing :name and :doc.
-    def provider_doc(type)
-      providers = []
-
-      type.providers.sort.each do |prov|
-        providers.push(:name => prov, :doc => type.provider(prov).doc)
-      end
-
-      providers
-    end
-  end
-end