openvox 8.19.0

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

@@ -0,0 +1,288 @@
+# frozen_string_literal: true
+
+require 'pathname'
+
+require_relative '../../../puppet/forge'
+require_relative '../../../puppet/module_tool'
+require_relative '../../../puppet/module_tool/shared_behaviors'
+require_relative '../../../puppet/module_tool/install_directory'
+require_relative '../../../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]
+
+        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 Puppet.runtime[: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 = begin
+              Checksummer.run(mod.path)
+            rescue
+              []
+            end
+            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])
+            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
+
+            next if 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).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).include? node.version
+              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|
+            mod = installed_modules_source.by_name[rel.name.split('-').last]
+            next unless mod
+            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
+
+          child = releases.find { |x| x.name == name }
+
+          unless forced?
+            if child.version == results[:installed_version]
+              versions = graph.dependencies[name].map(&: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(&:prepare)
+
+          Puppet.notice _('Upgrading -- do not interrupt ...')
+          releases.each do |release|
+            installed = installed_modules[release.name]
+            if installed
+              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
+
+      # rubocop:disable Naming/MemoizedInstanceVariableName
+      def module_repository
+        @repo ||= Puppet::Forge.new(Puppet[:module_repository])
+      end
+
+      def installed_modules_source
+        @installed ||= Puppet::ModuleTool::InstalledModules.new(@environment)
+      end
+      # rubocop:enable Naming/MemoizedInstanceVariableName
+
+      def installed_modules
+        installed_modules_source.modules
+      end
+
+      def build_single_module_graph(name, version)
+        range = Puppet::Module.parse_range(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 = [])
+        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.filter_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
+
+        {
+          :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/lib/puppet/module_tool/applications.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+require_relative '../../puppet/module_tool'
+
+module Puppet::ModuleTool
+  module Applications
+    require_relative 'applications/application'
+    require_relative 'applications/checksummer'
+    require_relative 'applications/installer'
+    require_relative 'applications/unpacker'
+    require_relative 'applications/uninstaller'
+    require_relative 'applications/upgrader'
+  end
+end

data/lib/puppet/module_tool/checksums.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+require 'digest/md5'
+require_relative '../../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)
+      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
+      @data
+    end
+
+    alias :to_data_hash :data
+    alias :to_hash :data
+
+    # TODO: Why?
+    def each(&block)
+      data.each(&block)
+    end
+  end
+end

data/lib/puppet/module_tool/dependency.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+require_relative '../../puppet/module_tool'
+require_relative '../../puppet/network/format_support'
+
+module Puppet::ModuleTool
+  class Dependency
+    include Puppet::Network::FormatSupport
+
+    attr_reader :full_module_name, :username, :name, :version_requirement, :repository
+
+    # Instantiates a new module dependency with a +full_module_name+ (e.g.
+    # "myuser-mymodule"), and optional +version_requirement+ (e.g. "0.0.1") and
+    # optional repository (a URL string).
+    def initialize(full_module_name, version_requirement = nil, repository = nil)
+      @full_module_name = full_module_name
+      # TODO: add error checking, the next line raises ArgumentError when +full_module_name+ is invalid
+      @username, @name = Puppet::ModuleTool.username_and_modname_from(full_module_name)
+      @version_requirement = version_requirement
+      @repository = repository ? Puppet::Forge::Repository.new(repository, nil) : nil
+    end
+
+    # We override Object's ==, eql, and hash so we can more easily find identical
+    # dependencies.
+    def ==(o)
+      hash == o.hash
+    end
+
+    alias :eql? :==
+
+    def hash
+      [@full_module_name, @version_requirement, @repository].hash
+    end
+
+    def to_data_hash
+      result = { :name => @full_module_name }
+      result[:version_requirement] = @version_requirement if @version_requirement && !@version_requirement.nil?
+      result[:repository] = @repository.to_s if @repository && !@repository.nil?
+      result
+    end
+  end
+end

data/lib/puppet/module_tool/errors/base.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module Puppet::ModuleTool::Errors
+  class ModuleToolError < Puppet::Error
+    def v(version)
+      (version || '???').to_s.sub(/^(?=\d)/, 'v')
+    end
+
+    def vstring
+      if @action == :upgrade
+        "#{v(@installed_version)} -> #{v(@requested_version)}"
+      else
+        v(@installed_version || @requested_version).to_s
+      end
+    end
+  end
+end

data/lib/puppet/module_tool/errors/installer.rb

@@ -0,0 +1,94 @@
+# frozen_string_literal: true
+
+module Puppet::ModuleTool::Errors
+  class InstallError < ModuleToolError; end
+
+  class AlreadyInstalledError < InstallError
+    def initialize(options)
+      @module_name       = options[:module_name]
+      @installed_version = v(options[:installed_version])
+      @requested_version = v(options[:requested_version])
+      @local_changes     = options[:local_changes]
+      super _("'%{module_name}' (%{version}) requested; '%{module_name}' (%{installed_version}) already installed") % { module_name: @module_name, version: @requested_version, installed_version: @installed_version }
+    end
+
+    def multiline
+      message = []
+      message << _("Could not install module '%{module_name}' (%{version})") % { module_name: @module_name, version: @requested_version }
+      message << _("  Module '%{module_name}' (%{installed_version}) is already installed") % { module_name: @module_name, installed_version: @installed_version }
+      message << _("    Installed module has had changes made locally") unless @local_changes.empty?
+      # TRANSLATORS `puppet module upgrade` is a command line and should not be translated
+      message << _("    Use `puppet module upgrade` to install a different version")
+      # TRANSLATORS `puppet module install --force` is a command line and should not be translated
+      message << _("    Use `puppet module install --force` to re-install only this module")
+      message.join("\n")
+    end
+  end
+
+  class MissingPackageError < InstallError
+    def initialize(options)
+      @requested_package = options[:requested_package]
+      @source = options[:source]
+
+      super _("Could not install '%{requested_package}'; no releases are available from %{source}") % { requested_package: @requested_package, source: @source }
+    end
+
+    def multiline
+      message = []
+      message << _("Could not install '%{requested_package}'") % { requested_package: @requested_package }
+      message << _("  No releases are available from %{source}") % { source: @source }
+      message << _("    Does '%{requested_package}' have at least one published release?") % { requested_package: @requested_package }
+      message.join("\n")
+    end
+  end
+
+  class InstallPathExistsNotDirectoryError < InstallError
+    def initialize(original, options)
+      @requested_module  = options[:requested_module]
+      @requested_version = options[:requested_version]
+      @directory         = options[:directory]
+      super(_("'%{module_name}' (%{version}) requested; Path %{dir} is not a directory.") % { module_name: @requested_module, version: @requested_version, dir: @directory }, original)
+    end
+
+    def multiline
+      message = []
+      message << _("Could not install module '%{module_name}' (%{version})") % { module_name: @requested_module, version: @requested_version }
+      message << _("  Path '%{directory}' exists but is not a directory.") % { directory: @directory }
+      # TRANSLATORS "mkdir -p '%{directory}'" is a command line example and should not be translated
+      message << _("  A potential solution is to rename the path and then \"mkdir -p '%{directory}'\"") % { directory: @directory }
+      message.join("\n")
+    end
+  end
+
+  class PermissionDeniedCreateInstallDirectoryError < InstallError
+    def initialize(original, options)
+      @requested_module  = options[:requested_module]
+      @requested_version = options[:requested_version]
+      @directory         = options[:directory]
+      super(_("'%{module_name}' (%{version}) requested; Permission is denied to create %{dir}.") % { module_name: @requested_module, version: @requested_version, dir: @directory }, original)
+    end
+
+    def multiline
+      message = []
+      message << _("Could not install module '%{module_name}' (%{version})") % { module_name: @requested_module, version: @requested_version }
+      message << _("  Permission is denied when trying to create directory '%{directory}'.") % { directory: @directory }
+      message << _('  A potential solution is to check the ownership and permissions of parent directories.')
+      message.join("\n")
+    end
+  end
+
+  class InvalidPathInPackageError < InstallError
+    def initialize(options)
+      @entry_path = options[:entry_path]
+      @directory  = options[:directory]
+      super _("Attempt to install file with an invalid path into %{path} under %{dir}") % { path: @entry_path.inspect, dir: @directory.inspect }
+    end
+
+    def multiline
+      message = []
+      message << _('Could not install package with an invalid path.')
+      message << _('  Package attempted to install file into %{path} under %{directory}.') % { path: @entry_path.inspect, directory: @directory.inspect }
+      message.join("\n")
+    end
+  end
+end