RubyGems - bolt - Versions diffs - 0.19.1 → 0.20.0 - Mend

bolt 0.19.1 → 0.20.0

Potentially problematic release.

This version of bolt might be problematic. Click here for more details.

Files changed (1261) hide show

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

@@ -1,62 +0,0 @@
-require 'json'
-require 'puppet/module_tool/checksums'
-module Puppet::ModuleTool
-  module Applications
-    class Checksummer < Application
-      def initialize(path, options = {})
-        @path = Pathname.new(path)
-        super(options)
-      end
-      def run
-        changes = []
-        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
-        end
-        # Return an Array of strings representing file paths of files that have
-        # been modified since this module was installed. All paths are relative
-        # to the installed module directory. This return value is used by the
-        # module_tool face changes action, and displayed on the console.
-        #
-        # Example return value:
-        #
-        #   [ "REVISION", "manifests/init.pp"]
-        #
-        changes
-      end
-      private
-      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'
-      end
-      def checksums_file
-        @path + 'checksums.json'
-      end
-    end
-  end
-end

data/vendored/puppet/lib/puppet/module_tool/applications/installer.rb DELETED

@@ -1,355 +0,0 @@
-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
-        @strict_semver       = !!options[:strict_semver]
-        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
-        # Disallow anything that invokes md5 to avoid un-friendly termination due to FIPS
-        raise _("Module install is prohibited in FIPS mode.") if Facter.value(:fips_enabled)
-        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 Puppet::Module.parse_range(version, @strict_semver).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 %{host} ...") % { host: 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|
-                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("#{mod} constraint", dep_name, range) do |node|
-                  Puppet::Module.parse_range(range, @strict_semver).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(Puppet[:module_repository], @strict_semver)
-      end
-      def local_tarball_source
-        @tarball_source ||= begin
-          Puppet::ModuleTool::LocalTarball.new(@name, @strict_semver)
-        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 = 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 = [])
-        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 => SemanticPuppet::Version.parse(@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

data/vendored/puppet/lib/puppet/module_tool/applications/searcher.rb DELETED

@@ -1,29 +0,0 @@
-module Puppet::ModuleTool
-  module Applications
-    class Searcher < Application
-      include Puppet::Forge::Errors
-      def initialize(term, forge, options = {})
-        @term = term
-        @forge = forge
-        super(options)
-      end
-      def run
-        results = {}
-        begin
-          Puppet.notice _("Searching %{host} ...") % { host: @forge.host }
-          results[:answers] = @forge.search(@term)
-          results[:result] = :success
-        rescue ForgeError => e
-          results[:result] = :failure
-          results[:error] = {
-            :oneline   => e.message,
-            :multiline => e.multiline,
-          }
-        end
-        results
-      end
-    end
-  end
-end

data/vendored/puppet/lib/puppet/module_tool/applications/uninstaller.rb DELETED

@@ -1,121 +0,0 @@
-module Puppet::ModuleTool
-  module Applications
-    class Uninstaller < Application
-      include Puppet::ModuleTool::Errors
-      def initialize(name, options)
-        @name        = name
-        @options     = options
-        @errors      = Hash.new {|h, k| h[k] = {}}
-        @unfiltered  = []
-        @installed   = []
-        @suggestions = []
-        @environment = options[:environment_instance]
-        @ignore_changes = options[:force] || options[:ignore_changes]
-        @strict_semver  = !!options[:strict_semver]
-      end
-      def run
-        # Disallow anything that invokes md5 to avoid un-friendly termination due to FIPS
-        raise _("Module uninstall is prohibited in FIPS mode.") if Facter.value(:fips_enabled)
-        results = {
-          :module_name       => @name,
-          :requested_version => @version,
-        }
-        begin
-          find_installed_module
-          validate_module
-          FileUtils.rm_rf(@installed.first.path, :secure => true)
-          results[:affected_modules] = @installed
-          results[:result] = :success
-        rescue ModuleToolError => err
-          results[:error] = {
-            :oneline   => err.message,
-            :multiline => err.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 find_installed_module
-        @environment.modules_by_path.values.flatten.each do |mod|
-          mod_name = (mod.forge_name || mod.name).gsub('/', '-')
-          if mod_name == @name
-            @unfiltered << {
-              :name    => mod_name,
-              :version => mod.version,
-              :path    => mod.modulepath,
-            }
-            if @options[:version] && mod.version
-              next unless Puppet::Module.parse_range(@options[:version], @strict_semver).include?(SemanticPuppet::Version.parse(mod.version))
-            end
-            @installed << mod
-          elsif mod_name =~ /#{@name}/
-            @suggestions << mod_name
-          end
-        end
-        if @installed.length > 1
-          raise MultipleInstalledError,
-            :action            => :uninstall,
-            :module_name       => @name,
-            :installed_modules => @installed.sort_by { |mod| @environment.modulepath.index(mod.modulepath) }
-        elsif @installed.empty?
-          if @unfiltered.empty?
-            raise NotInstalledError,
-              :action      => :uninstall,
-              :suggestions => @suggestions,
-              :module_name => @name
-          else
-            raise NoVersionMatchesError,
-              :installed_modules => @unfiltered.sort_by { |mod| @environment.modulepath.index(mod[:path]) },
-              :version_range     => @options[:version],
-              :module_name       => @name
-          end
-        end
-      end
-      def validate_module
-        mod = @installed.first
-        unless @ignore_changes
-          changes = begin
-            Puppet::ModuleTool::Applications::Checksummer.run(mod.path)
-          rescue ArgumentError
-            []
-          end
-          if mod.has_metadata? && !changes.empty?
-            raise LocalChangesError,
-              :action            => :uninstall,
-              :module_name       => (mod.forge_name || mod.name).gsub('/', '-'),
-              :requested_version => @options[:version],
-              :installed_version => mod.version
-          end
-        end
-        if !@options[:force] && !mod.required_by.empty?
-          raise ModuleIsRequiredError,
-            :module_name       => (mod.forge_name || mod.name).gsub('/', '-'),
-            :required_by       => mod.required_by,
-            :requested_version => @options[:version],
-            :installed_version => mod.version
-        end
-      end
-    end
-  end
-end