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

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

@@ -2,11 +2,13 @@ require 'open-uri'
 require 'pathname'
 require 'fileutils'
 require 'tmpdir'
-require 'semver'
+
 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
@@ -15,60 +17,166 @@ module Puppet::ModuleTool
       include Puppet::ModuleTool::Errors
       include Puppet::Forge::Errors
 
-      def initialize(name, forge, install_dir, options = {})
+      def initialize(name, install_dir, options = {})
         super(options)
+
         @action              = :install
         @environment         = options[:environment_instance]
-        @force               = options[:force]
-        @ignore_dependencies = options[:force] || options[:ignore_dependencies]
+        @ignore_dependencies = forced? || options[:ignore_dependencies]
         @name                = name
-        @forge               = forge
         @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
+          Semantic::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
+            Semantic::Dependency.add_source(installed_modules_source)
+            Semantic::Dependency.add_source(module_repository)
+          end
+
+        else
+          Semantic::Dependency.add_source(installed_modules_source) unless forced?
+          Semantic::Dependency.add_source(module_repository)
+        end
       end
 
       def run
-        results = {}
+        name = @name.tr('/', '-')
+        version = options[:version] || '>= 0.0.0'
+
+        results = { :action => :install, :module_name => name, :module_version => version }
+
         begin
-          if is_module_package?(@name)
-            @source = :filesystem
-            @filename = File.expand_path(@name)
-            raise MissingPackageError, :requested_package => @filename unless Puppet::FileSystem.exist?(@filename)
-
-            parsed = parse_filename(@filename)
-            @module_name = parsed[:module_name]
-            @version     = parsed[:version]
+          if mod = installed_modules[name]
+            unless forced?
+              if Semantic::VersionRange.parse(version).include? mod.version
+                results[:result] = :noop
+                results[:version] = mod.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
-            @source = :repository
-            @module_name = @name.gsub('/', '-')
-            @version = options[:version]
+            graph = build_dependency_graph(name, version)
           end
 
-          results = {
-            :module_name    => @module_name,
-            :module_version => @version,
-            :install_dir    => options[:target_dir],
-          }
+          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.
+              ">=#{version} #{version.major}.x".tap do |range|
+                graph.add_constraint('installed', mod, range) do |node|
+                  Semantic::VersionRange.parse(range).include? node.version
+                end
+              end
+
+              release.mod.dependencies.each do |dep|
+                dep_name = dep['name'].tr('/', '-')
+
+                dep['version_requirement'].tap do |range|
+                  graph.add_constraint("#{mod} constraint", dep_name, range) do |node|
+                    Semantic::VersionRange.parse(range).include? node.version
+                  end
+                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 = Semantic::Dependency.resolve(graph)
+          rescue Semantic::Dependency::UnsatisfiableGraph
+            raise NoVersionsSatisfyError, results.merge(:requested_name => name)
+          end
 
-          @install_dir.prepare(@module_name, @version || 'latest')
+          unless forced?
+            # Check for module name conflicts.
+            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
 
-          cached_paths = get_release_packages
+                if rel.name != name
+                  dependency = {
+                    :name => rel.name,
+                    :version => rel.version
+                  }
+                end
 
-          unless @graph.empty?
-            Puppet.notice 'Installing -- do not interrupt ...'
-            cached_paths.each do |hash|
-              hash.each do |dir, path|
-                Unpacker.new(path, @options.merge(:target_dir => dir)).run
+                raise InstallConflictError,
+                  :requested_module  => name,
+                  :requested_version => options[:version] || 'latest',
+                  :dependency        => dependency,
+                  :directory         => mod.path,
+                  :metadata          => mod.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,
           }
-        else
-          results[:result] = :success
-          results[:installed_modules] = @graph
         ensure
           results[:result] ||= :failure
         end
@@ -78,6 +186,60 @@ module Puppet::ModuleTool
 
       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 = Semantic::VersionRange.parse(version)
+        graph = Semantic::Dependency::Graph.new(name => range)
+        releases = Semantic::Dependency.fetch_releases(name)
+        releases.each { |release| release.dependencies.clear }
+        graph << releases
+      end
+
+      def build_dependency_graph(name, version)
+        Semantic::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
@@ -85,8 +247,7 @@ module Puppet::ModuleTool
       def get_release_packages
         get_local_constraints
 
-        if !@force && @installed.include?(@module_name)
-
+        if !forced? && @installed.include?(@module_name)
           raise AlreadyInstalledError,
             :module_name       => @module_name,
             :installed_version => @installed[@module_name].first.version,
@@ -108,7 +269,7 @@ module Puppet::ModuleTool
 
         @graph = resolve_constraints({ @module_name => @version })
         @graph.first[:tarball] = @filename if @source == :filesystem
-        resolve_install_conflicts(@graph) unless @force
+        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

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

@@ -12,6 +12,7 @@ module Puppet::ModuleTool
       def run
         results = {}
         begin
+          Puppet.notice "Searching #{@forge.host} ..."
           results[:answers] = @forge.search(@term)
           results[:result] = :success
         rescue ForgeError => e

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

@@ -22,6 +22,7 @@ module Puppet::ModuleTool
         begin
           find_installed_module
           validate_module
+
           FileUtils.rm_rf(@installed.first.path, :secure => true)
 
           results[:affected_modules] = @installed
@@ -87,7 +88,12 @@ module Puppet::ModuleTool
         mod = @installed.first
 
         if !@options[:force] && mod.has_metadata?
-          changes = Puppet::ModuleTool::Applications::Checksummer.run(mod.path)
+          changes = begin
+            Puppet::ModuleTool::Applications::Checksummer.run(mod.path)
+          rescue ArgumentError
+            []
+          end
+
           if !changes.empty?
             raise LocalChangesError,
               :action            => :uninstall,

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

@@ -1,59 +1,85 @@
 require 'pathname'
 require 'tmpdir'
+require 'json'
 
 module Puppet::ModuleTool
   module Applications
     class Unpacker < Application
+      def self.unpack(filename, target)
+        app = self.new(filename, :target_dir => target)
+        app.unpack
+        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)
-        parsed = parse_filename(filename)
-        @module_name = parsed[:module_name]
         super(options)
         @module_path = Pathname(options[:target_dir])
-        @module_dir = @module_path + parsed[:dir_name]
       end
 
       def run
-        extract_module_to_install_dir
+        unpack
+        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, and the module release
-        # name.
-        @module_dir
+        # module release archive was unpacked the to.
+        return module_dir
       end
 
-      # Obtain a suitable temporary path for building and unpacking tarballs
-      #
-      # @return [Pathname] path to temporary build location
-      def build_dir
-        Puppet::Forge::Cache.base_path + "tmp-unpacker-#{Digest::SHA1.hexdigest(@filename.basename.to_s)}"
+      # @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: #{e.message}"
+        end
       end
 
-      private
+      # @api private
+      def root_dir
+        return @root_dir if @root_dir
 
-      def extract_module_to_install_dir
-        delete_existing_installation_or_abort!
+        # Grab the first directory containing a metadata.json file
+        metadata_file = Dir["#{tmpdir}/**/metadata.json"].sort_by(&:length)[0]
 
-        build_dir.mkpath
-        begin
-          begin
-            Puppet::ModuleTool::Tar.instance(@module_name).unpack(@filename.to_s, build_dir.to_s, [@module_path.stat.uid, @module_path.stat.gid].join(':'))
-          rescue Puppet::ExecutionFailure => e
-            raise RuntimeError, "Could not extract contents of module archive: #{e.message}", e.backtrace
-          end
-
-          # grab the first directory
-          extracted = build_dir.children.detect { |c| c.directory? }
-          FileUtils.mv extracted, @module_dir
-        ensure
-          build_dir.rmtree
+        if metadata_file
+          @root_dir = Pathname.new(metadata_file).dirname
+        else
+          raise "No valid metadata.json found!"
         end
       end
 
-      def delete_existing_installation_or_abort!
-        return unless @module_dir.exist?
-        FileUtils.rm_rf(@module_dir, :secure => true)
+      # @api private
+      def module_name
+        metadata = JSON.parse((root_dir + 'metadata.json').read)
+        name = 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-unpacker', Puppet::Forge::Cache.base_path)
       end
     end
   end

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

@@ -1,112 +1,268 @@
+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, forge, options)
+      def initialize(name, options)
+        super(options)
+
         @action              = :upgrade
         @environment         = options[:environment_instance]
-        @module_name         = name
-        @options             = options
-        @force               = options[:force]
-        @ignore_dependencies = options[:force] || options[:ignore_dependencies]
-        @version             = options[:version]
-        @forge               = forge
+        @name                = name
+        @ignore_dependencies = forced? || options[:ignore_dependencies]
+
+        Semantic::Dependency.add_source(installed_modules_source)
+        Semantic::Dependency.add_source(module_repository)
       end
 
       def run
+        name = @name.tr('/', '-')
+        version = options[:version] || '>= 0.0.0'
+
+        results = {
+          :action => :upgrade,
+          :requested_version => options[:version] || :latest,
+        }
+
         begin
-          results = { :module_name => @module_name }
-
-          get_local_constraints
-
-          if @installed[@module_name].length > 1
-            raise MultipleInstalledError,
-              :action            => :upgrade,
-              :module_name       => @module_name,
-              :installed_modules => @installed[@module_name].sort_by { |mod| @environment.modulepath.index(mod.modulepath) }
-          elsif @installed[@module_name].empty?
-            raise NotInstalledError,
-              :action      => :upgrade,
-              :module_name => @module_name
+          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
 
-          @module = @installed[@module_name].last
-          results[:installed_version] = @module.version ? @module.version.sub(/^(?=\d)/, 'v') : nil
-          results[:requested_version] = @version || (@conditions[@module_name].empty? ? :latest : :best)
-          dir = @module.modulepath
+          mod = installed_modules[name]
 
-          Puppet.notice "Found '#{@module_name}' (#{colorize(:cyan, results[:installed_version] || '???')}) in #{dir} ..."
-          if !@options[:force] && @module.has_metadata?
-            changes = Puppet::ModuleTool::Applications::Checksummer.run(@module.path)
-            if !changes.empty?
+          # `priority` is an attribute of a `Semantic::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 mod.priority
+            0
+          end
+
+          mod = mod.mod
+          results[:installed_version] = Semantic::Version.parse(mod.version)
+          dir = Pathname.new(mod.modulepath)
+
+          vstring = mod.version ? "v#{mod.version}" : '???'
+          Puppet.notice "Found '#{name}' (#{colorize(:cyan, vstring)}) in #{dir} ..."
+          unless forced?
+            changes = Checksummer.run(mod.path) rescue []
+            if mod.has_metadata? && !changes.empty?
               raise LocalChangesError,
                 :action            => :upgrade,
-                :module_name       => @module_name,
-                :requested_version => @version || (@conditions[@module_name].empty? ? :latest : :best),
-                :installed_version => @module.version
+                :module_name       => name,
+                :requested_version => results[:requested_version],
+                :installed_version => mod.version
             end
           end
 
-          begin
-            get_remote_constraints(@forge)
-          rescue => e
-            raise UnknownModuleError, results.merge(:repository => @forge.uri), e.backtrace
+          Puppet::Forge::Cache.clean
+
+          Puppet.notice "Downloading from #{module_repository.host} ..."
+          if @ignore_dependencies
+            graph = build_single_module_graph(name, version)
           else
-            raise UnknownVersionError, results.merge(:repository => @forge.uri) if @remote.empty?
+            graph = build_dependency_graph(name, version)
           end
 
-          if !@options[:force] && @versions["#{@module_name}"].last[:vstring].sub(/^(?=\d)/, 'v') == (@module.version || '0.0.0').sub(/^(?=\d)/, 'v')
-            raise VersionAlreadyInstalledError,
-              :module_name       => @module_name,
-              :requested_version => @version || ((@conditions[@module_name].empty? ? 'latest' : 'best') + ": #{@versions["#{@module_name}"].last[:vstring].sub(/^(?=\d)/, 'v')}"),
-              :installed_version => @installed[@module_name].last.version,
-              :conditions        => @conditions[@module_name] + [{ :module => :you, :version => @version }]
+          unless forced?
+            add_module_name_constraints_to_graph(graph)
           end
 
-          @graph = resolve_constraints({ @module_name => @version })
+          installed_modules.each do |mod, release|
+            mod = mod.tr('/', '-')
+            next if mod == name
 
-          # 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
-          tarballs = download_tarballs(@graph, @graph.last[:path], @forge)
+            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.
+              ">=#{version} #{version.major}.x".tap do |range|
+                graph.add_constraint('installed', mod, range) do |node|
+                  Semantic::VersionRange.parse(range).include? node.version
+                end
+              end
+
+              release.mod.dependencies.each do |dep|
+                dep_name = dep['name'].tr('/', '-')
+
+                dep['version_requirement'].tap do |range|
+                  graph.add_constraint("#{mod} constraint", dep_name, range) do |node|
+                    Semantic::VersionRange.parse(range).include? node.version
+                  end
+                end
+              end
+            end
+          end
+
+          # Ensure that there is at least one candidate release available
+          # for the target package.
+          if graph.dependencies[name].empty? || graph.dependencies[name] == SortedSet.new([ installed_modules[name] ])
+            if results[:requested_version] == :latest || !Semantic::VersionRange.parse(results[:requested_version]).include?(results[:installed_version])
+              raise NoCandidateReleasesError, results.merge(:module_name => name, :source => module_repository.host)
+            end
+          end
+
+          begin
+            Puppet.info "Resolving dependencies ..."
+            releases = Semantic::Dependency.resolve(graph)
+          rescue Semantic::Dependency::UnsatisfiableGraph
+            raise NoVersionsSatisfyError, results.merge(:requested_name => name)
+          end
 
-          unless @graph.empty?
-            Puppet.notice 'Upgrading -- do not interrupt ...'
-            tarballs.each do |hash|
-              hash.each do |dir, path|
-                Unpacker.new(path, @options.merge(:target_dir => dir)).run
+          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 }
+            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] = @graph.first[:path]
-          results[:affected_modules] = @graph
+          results[:base_dir] = releases.first.install_dir
+          results[:affected_modules] = releases
+          results[:graph] = [ build_install_graph(releases.first, releases) ]
+
         rescue VersionAlreadyInstalledError => e
-          results[:result] = :noop
-          results[:error] = {
-            :oneline   => e.message,
-            :multiline => e.multiline
-          }
+          results[:result] = (e.newer_versions.empty? ? :noop : :failure)
+          results[:error] = { :oneline => e.message, :multiline => e.multiline }
         rescue => e
           results[:error] = {
-            :oneline => e.message,
+            :oneline   => e.message,
             :multiline => e.respond_to?(:multiline) ? e.multiline : [e.to_s, e.backtrace].join("\n")
           }
         ensure
           results[:result] ||= :failure
         end
 
-        return results
+        results
       end
 
       private
+      def module_repository
+        @repo ||= Puppet::Forge.new
+      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 = Semantic::VersionRange.parse(version)
+        graph = Semantic::Dependency::Graph.new(name => range)
+        releases = Semantic::Dependency.fetch_releases(name)
+        releases.each { |release| release.dependencies.clear }
+        graph << releases
+      end
+
+      def build_dependency_graph(name, version)
+        Semantic::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