puppet-parse 0.0.1 → 0.0.2

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

@@ -0,0 +1,183 @@
+require 'open-uri'
+require 'pathname'
+require 'tmpdir'
+require 'semver'
+require 'puppet/forge'
+require 'puppet/module_tool'
+require 'puppet/module_tool/shared_behaviors'
+
+module Puppet::ModuleTool
+  module Applications
+    class Installer < Application
+
+      include Puppet::ModuleTool::Errors
+
+      def initialize(name, options = {})
+        @action              = :install
+        @environment         = Puppet::Node::Environment.new(Puppet.settings[:environment])
+        @force               = options[:force]
+        @ignore_dependencies = options[:force] || options[:ignore_dependencies]
+        @name                = name
+        super(options)
+      end
+
+      def run
+        begin
+          if is_module_package?(@name)
+            @source = :filesystem
+            @filename = File.expand_path(@name)
+            raise MissingPackageError, :requested_package => @filename unless File.exist?(@filename)
+
+            parsed = parse_filename(@filename)
+            @module_name = parsed[:module_name]
+            @version     = parsed[:version]
+          else
+            @source = :repository
+            @module_name = @name.gsub('/', '-')
+            @version = options[:version]
+          end
+
+          results = {
+            :module_name    => @module_name,
+            :module_version => @version,
+            :install_dir    => options[:target_dir],
+          }
+
+          unless File.directory? options[:target_dir]
+            raise MissingInstallDirectoryError,
+              :requested_module  => @module_name,
+              :requested_version => @version || 'latest',
+              :directory         => options[:target_dir]
+          end
+
+          cached_paths = get_release_packages
+
+          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
+              end
+            end
+          end
+        rescue ModuleToolError => err
+          results[:error] = {
+            :oneline   => err.message,
+            :multiline => err.multiline,
+          }
+        else
+          results[:result] = :success
+          results[:installed_modules] = @graph
+        ensure
+          results[:result] ||= :failure
+        end
+
+        results
+      end
+
+      private
+
+      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 !@force && @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     => @installed[@module_name].first.local_changes
+        end
+
+        if @ignore_dependencies && @source == :filesystem
+          @urls   = {}
+          @remote = { "#{@module_name}@#{@version}" => { } }
+          @versions = {
+            @module_name => [
+              { :vstring => @version, :semver => SemVer.new(@version) }
+            ]
+          }
+        else
+          get_remote_constraints
+        end
+
+        @graph = resolve_constraints({ @module_name => @version })
+        @graph.first[:tarball] = @filename if @source == :filesystem
+        resolve_install_conflicts(@graph) unless @force
+
+        # 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])
+      end
+
+      #
+      # Resolve installation conflicts by checking if the requested module
+      # or one of it's 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)
+        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
+              latest_version = @versions["#{@module_name}"].sort_by { |h| h[:semver] }.last[:vstring]
+
+              raise InstallConflictError,
+                :requested_module  => @module_name,
+                :requested_version => @version || "latest: v#{latest_version}",
+                :dependency        => dependency,
+                :directory         => mod.path,
+                :metadata          => metadata
+            end
+
+            resolve_install_conflicts(release[:dependencies], 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 acutal 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/lib/vendor/puppet/module_tool/applications/searcher.rb

@@ -0,0 +1,15 @@
+module Puppet::ModuleTool
+  module Applications
+    class Searcher < Application
+
+      def initialize(term, options = {})
+        @term = term
+        super(options)
+      end
+
+      def run
+        Puppet::Forge.search(@term)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,107 @@
+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 = Puppet::Node::Environment.new(options[:environment])
+      end
+
+      def run
+        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 SemVer[@options[:version]].include?(SemVer.new(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
+
+        if !@options[:force] && mod.has_metadata? && mod.has_local_changes?
+          raise LocalChangesError,
+            :action            => :uninstall,
+            :module_name       => (mod.forge_name || mod.name).gsub('/', '-'),
+            :requested_version => @options[:version],
+            :installed_version => mod.version
+        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

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

@@ -0,0 +1,67 @@
+require 'pathname'
+require 'tmpdir'
+
+module Puppet::ModuleTool
+  module Applications
+    class Unpacker < Application
+
+      def initialize(filename, options = {})
+        @filename = Pathname.new(filename)
+        parsed = parse_filename(filename)
+        super(options)
+        @module_dir = Pathname.new(options[:target_dir]) + parsed[:dir_name]
+      end
+
+      def run
+        extract_module_to_install_dir
+
+        # Return the Pathname object representing the directory where the
+        # module release archive was unpacked the to, and the module release
+        # name.
+        @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)}"
+      end
+
+      private
+      def extract_module_to_install_dir
+        delete_existing_installation_or_abort!
+
+        build_dir.mkpath
+        begin
+          begin
+            if Facter.value('operatingsystem') == "Solaris"
+              # Solaris tar is not as safe and works differently, so we prefer
+              # gnutar instead.
+              if Puppet::Util.which('gtar')
+                Puppet::Util.execute("gtar xzf #{@filename} -C #{build_dir}")
+              else
+                raise RuntimeError, "Cannot find the command 'gtar'. Make sure GNU tar is installed, and is in your PATH."
+              end
+            else
+              Puppet::Util.execute("tar xzf #{@filename} -C #{build_dir}")
+            end
+          rescue Puppet::ExecutionFailure => e
+            raise RuntimeError, "Could not extract contents of module archive: #{e.message}"
+          end
+
+          # grab the first directory
+          extracted = build_dir.children.detect { |c| c.directory? }
+          FileUtils.mv extracted, @module_dir
+        ensure
+          build_dir.rmtree
+        end
+      end
+
+      def delete_existing_installation_or_abort!
+        return unless @module_dir.exist?
+        FileUtils.rm_rf(@module_dir, :secure => true)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,109 @@
+module Puppet::ModuleTool
+  module Applications
+    class Upgrader < Application
+
+      include Puppet::ModuleTool::Errors
+
+      def initialize(name, options)
+        @action              = :upgrade
+        @environment         = Puppet::Node::Environment.new(Puppet.settings[:environment])
+        @module_name         = name
+        @options             = options
+        @force               = options[:force]
+        @ignore_dependencies = options[:force] || options[:ignore_dependencies]
+        @version             = options[:version]
+      end
+
+      def run
+        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
+          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
+
+          Puppet.notice "Found '#{@module_name}' (#{colorize(:cyan, results[:installed_version] || '???')}) in #{dir} ..."
+          if !@options[:force] && @module.has_metadata? && @module.has_local_changes?
+            raise LocalChangesError,
+              :action            => :upgrade,
+              :module_name       => @module_name,
+              :requested_version => @version || (@conditions[@module_name].empty? ? :latest : :best),
+              :installed_version => @module.version
+          end
+
+          begin
+            get_remote_constraints
+          rescue => e
+            raise UnknownModuleError, results.merge(:repository => Puppet::Forge.repository.uri)
+          else
+            raise UnknownVersionError, results.merge(:repository => Puppet::Forge.repository.uri) if @remote.empty?
+          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 }]
+          end
+
+          @graph = resolve_constraints({ @module_name => @version })
+
+          # 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])
+
+          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
+              end
+            end
+          end
+
+          results[:result] = :success
+          results[:base_dir] = @graph.first[:path]
+          results[:affected_modules] = @graph
+        rescue VersionAlreadyInstalledError => e
+          results[:result] = :noop
+          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
+
+        return results
+      end
+
+      private
+      include Puppet::ModuleTool::Shared
+    end
+  end
+end

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

@@ -0,0 +1,15 @@
+require 'puppet/module_tool'
+
+module Puppet::ModuleTool
+  module Applications
+    require 'puppet/module_tool/applications/application'
+    require 'puppet/module_tool/applications/builder'
+    require 'puppet/module_tool/applications/checksummer'
+    require 'puppet/module_tool/applications/generator'
+    require 'puppet/module_tool/applications/installer'
+    require 'puppet/module_tool/applications/searcher'
+    require 'puppet/module_tool/applications/unpacker'
+    require 'puppet/module_tool/applications/uninstaller'
+    require 'puppet/module_tool/applications/upgrader'
+  end
+end

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

@@ -0,0 +1,52 @@
+require 'digest/md5'
+
+module Puppet::ModuleTool
+
+  # = Checksums
+  #
+  # This class proides methods for generating checksums for data and adding
+  # them to +Metadata+.
+  class Checksums
+    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(pathname.read)
+    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
+
+    # TODO: Why?
+    def each(&block)
+      data.each(&block)
+    end
+
+    # Update +Metadata+'s checksums with this object's.
+    def annotate(metadata)
+      metadata.checksums.replace(data)
+    end
+
+    # TODO: Move the Checksummer#run checksum checking to here?
+
+  end
+end

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

@@ -0,0 +1,82 @@
+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 |type_name|
+          if type = Puppet::Type.type(type_name.to_sym)
+            type_hash = {:name => type_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: #{type_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)
+      [].tap do |attrs|
+        type.allattrs.each do |name|
+          if type.attrtype(name) == kind && name != :provider
+            attrs.push(:name => name, :doc => type.attrclass(name).doc)
+          end
+        end
+      end
+    end
+
+    # Return an array of hashes representing this +type+'s providers, each
+    # containing :name and :doc.
+    def provider_doc(type)
+      [].tap do |providers|
+        type.providers.sort.each do |prov|
+          providers.push(:name => prov, :doc => type.provider(prov).doc)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,24 @@
+module Puppet::ModuleTool
+
+  class Dependency
+
+    # 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
+    end
+
+    # Return PSON representation of this data.
+    def to_pson(*args)
+      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.to_pson(*args)
+    end
+  end
+end

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

@@ -0,0 +1,15 @@
+module Puppet::ModuleTool::Errors
+  class ModuleToolError < StandardError
+    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)}"
+      end
+    end
+  end
+end