puppet 2.7.11 → 2.7.12

data/lib/puppet/face/ca.rb

@@ -75,7 +75,7 @@ Puppet::Face.define(:ca, '0.1.0') do
         raise "Unable to fetch the CA"
       end
 
-      length = hosts.map{|x| x.name.length }.max + 1
+      length = hosts.map{|x| x.name.length }.max.to_i + 1
 
       hosts.map do |host|
         name = host.name.ljust(length)

data/lib/puppet/face/catalog.rb

@@ -66,6 +66,7 @@ Puppet::Indirector::Face.define(:catalog, '0.0.1') do
 
       report = Puppet::Transaction::Report.new("apply")
       report.configuration_version = catalog.version
+      report.environment = Puppet[:environment]
 
       Puppet::Util::Log.newdestination(report)
 

data/lib/puppet/face/file/store.rb

@@ -11,7 +11,7 @@ Puppet::Face.define(:file, '0.0.1') do
     EOT
 
     when_invoked do |path, options|
-      file = Puppet::FileBucket::File.new(Puppet::Util.binread(path))
+      file = Puppet::FileBucket::File.new(IO.binread(path))
 
       Puppet::FileBucket::File.indirection.terminus_class = :file
       Puppet::FileBucket::File.indirection.save file

data/lib/puppet/face/module/list.rb

@@ -3,7 +3,9 @@ Puppet::Face.define(:module, '1.0.0') do
     summary "List installed modules"
     description <<-HEREDOC
       List puppet modules from a specific environment, specified modulepath or
-      default to listing modules in the default modulepath:
+      default to listing modules in the default modulepath.  The output will
+      include information about unmet module dependencies based on information
+      from module metadata.
       #{Puppet.settings[:modulepath]}
     HEREDOC
     returns "hash of paths to module objects"
@@ -29,6 +31,9 @@ Puppet::Face.define(:module, '1.0.0') do
       List installed modules from a specified environment:
 
       $ puppet module list --env 'test'
+        Missing dependency `stdlib`:
+          `rrd` (0.0.2) requires `puppetlabs/stdlib` (>= 2.2.0)
+
         /tmp/puppet/modules
           rrd (0.0.2)
 
@@ -48,11 +53,26 @@ Puppet::Face.define(:module, '1.0.0') do
       environment.modules_by_path
     end
 
-    when_rendering :console do |modules_by_path|
+    when_rendering :console do |modules_by_path, options|
       output = ''
+
+      Puppet[:modulepath] = options[:modulepath] if options[:modulepath]
+      environment = Puppet::Node::Environment.new(options[:env])
+
+      dependency_errors = false
+
+      environment.modules.sort_by {|mod| mod.name}.each do |mod|
+        mod.unmet_dependencies.sort_by {|dep| dep[:name]}.each do |dep|
+          dependency_errors = true
+          $stderr.puts dep[:error]
+        end
+      end
+
+      output << "\n" if dependency_errors
+
       modules_by_path.each do |path, modules|
         output << "#{path}\n"
-        modules.each do |mod|
+        modules.sort_by {|mod| mod.name }.each do |mod|
           version_string = mod.version ? "(#{mod.version})" : ''
           output << "  #{mod.name} #{version_string}\n"
         end

data/lib/puppet/face/module/search.rb

@@ -11,32 +11,8 @@ Puppet::Face.define(:module, '1.0.0') do
       Search the default repository for a module:
 
       $ puppet module search puppetlabs
-      notice: Searching http://forge.puppetlabs.com
-      notice: 24 found.
-      puppetlabs/apache (0.0.3)
-      puppetlabs/collectd (0.0.1)
-      puppetlabs/ruby (0.0.1)
-      puppetlabs/vcsrepo (0.0.4)
-      puppetlabs/gcc (0.0.3)
-      puppetlabs/passenger (0.0.2)
-      puppetlabs/DeveloperBootstrap (0.0.5)
-      jeffmccune/tomcat (1.0.1)
-      puppetlabs/motd (1.0.0)
-      puppetlabs/lvm (0.1.0)
-      puppetlabs/rabbitmq (1.0.4)
-      puppetlabs/prosvc_repo (1.0.1)
-      puppetlabs/stdlib (2.2.0)
-      puppetlabs/java (0.1.5)
-      puppetlabs/activemq (0.1.6)
-      puppetlabs/mcollective (0.1.8)
-      puppetlabs/git (0.0.2)
-      puppetlabs/ntp (0.0.4)
-      puppetlabs/nginx (0.0.1)
-      puppetlabs/cloud_provisioner (0.6.0rc1)
-      puppetlabs/mrepo (0.1.1)
-      puppetlabs/f5 (0.1.0)
-      puppetlabs/firewall (0.0.3)
-      puppetlabs/bprobe (0.0.3)
+      NAME          DESCRIPTION                          AUTHOR             KEYWORDS
+      bacula        This is a generic Apache module      @puppetlabs        backups
     EOT
 
     arguments "<term>"
@@ -50,17 +26,30 @@ Puppet::Face.define(:module, '1.0.0') do
     end
 
     when_invoked do |term, options|
-      Puppet.notice "Searching #{options[:module_repository]}"
       Puppet::Module::Tool::Applications::Searcher.run(term, options)
     end
 
     when_rendering :console do |return_value|
-      Puppet.notice "#{return_value.size} found."
+
+      FORMAT = "%-10s    %-32s     %-14s     %s\n"
+
+      def header
+        FORMAT % ['NAME', 'DESCRIPTION', 'AUTHOR', 'KEYWORDS']
+      end
+
+      def format_row(name, description, author, tag_list)
+        keywords = tag_list.join(' ')
+        FORMAT % [name[0..10], description[0..32], "@#{author[0..14]}", keywords]
+      end
+
+      output = ''
+      output << header unless return_value.empty?
+
       return_value.map do |match|
-        # We reference the full_name here when referring to the full_module_name,
-        # because full_name is what is returned from the forge API call.
-        "#{match['full_name']} (#{match['version']})"
-      end.join("\n")
+        output << format_row(match['name'], match['desc'], match['author'], match['tag_list'])
+      end
+
+      output
     end
   end
 end

data/lib/puppet/face/module/uninstall.rb

@@ -7,44 +7,85 @@ Puppet::Face.define(:module, '1.0.0') do
       #{Puppet.settings[:modulepath].split(File::PATH_SEPARATOR).join(', ')}.
     EOT
 
-    returns "Array of strings representing paths of uninstalled files."
+    returns "Hash of module objects representing uninstalled modules and related errors."
 
     examples <<-EOT
       Uninstall a module from all directories in the modulepath:
 
       $ puppet module uninstall ssh
-      Removed /etc/puppet/modules/ssh
+      Removed /etc/puppet/modules/ssh (v1.0.0)
 
       Uninstall a module from a specific directory:
 
-      $ puppet module uninstall --target-directory /usr/share/puppet/modules ssh
-      Removed /usr/share/puppet/modules/ssh
+      $ puppet module uninstall --modulepath /usr/share/puppet/modules ssh
+      Removed /usr/share/puppet/modules/ssh (v1.0.0)
+
+      Uninstall a module from a specific environment:
+
+      $ puppet module uninstall --environment development 
+      Removed /etc/puppet/environments/development/modules/ssh (v1.0.0)
+      
+      Uninstall a specific version of a module:
+
+      $ puppet module uninstall --version 2.0.0 ssh
+      Removed /etc/puppet/modules/ssh (v2.0.0)
     EOT
 
     arguments "<name>"
 
-    option "--target-directory=", "-t=" do
-      default_to { Puppet.settings[:modulepath].split(File::PATH_SEPARATOR) }
-      summary "The target directory to search from modules."
+    option "--environment=NAME", "--env=NAME" do
+      default_to { "production" }
+      summary "The target environment to search for modules."
+      description <<-EOT
+        The target environment to search for modules.
+      EOT
+    end
+    
+    option "--version=" do
+      summary "The version of the module to uninstall"
+      description <<-EOT
+        The version of the module to uninstall. When using this option a module
+        that matches the specified version must be installed or an error is raised.
+      EOT
+    end
+
+    option "--modulepath=" do
+      summary "The target directory to search for modules."
       description <<-EOT
         The target directory to search for modules.
       EOT
     end
 
     when_invoked do |name, options|
-
-      if options[:target_directory].is_a?(Array)
-        options[:target_directories] = options[:target_directory]
-      else
-        options[:target_directories] = [ options[:target_directory] ]
+      if options[:modulepath]
+        unless File.directory?(options[:modulepath])
+          raise ArgumentError, "Directory #{options[:modulepath]} does not exist"
+        end
       end
-      options.delete(:target_directory)
+
+      Puppet[:modulepath] = options[:modulepath] if options[:modulepath]
+      options[:name] = name
 
       Puppet::Module::Tool::Applications::Uninstaller.run(name, options)
     end
 
-    when_rendering :console do |removed_modules|
-      removed_modules.map { |path| "Removed #{path}" }.join('\n')
+    when_rendering :console do |return_value|
+      output = ''
+
+      return_value[:removed_mods].each do |mod| 
+        output << "Removed #{mod.path} (v#{mod.version})\n"
+      end
+
+      return_value[:errors].map do |mod_name, errors|
+        if ! errors.empty?
+          header = "Could not uninstall module #{return_value[:options][:name]}"
+          header << " (v#{return_value[:options][:version]})" if return_value[:options][:version]
+          output << "#{header}:\n"
+          errors.map { |error| output << "  #{error}\n" }
+        end
+      end
+
+      output
     end
   end
 end

data/lib/puppet/file_bucket/dipper.rb

@@ -31,7 +31,7 @@ class Puppet::FileBucket::Dipper
   # Back up a file to our bucket
   def backup(file)
     raise(ArgumentError, "File #{file} does not exist") unless ::File.exist?(file)
-    contents = Puppet::Util.binread(file)
+    contents = IO.binread(file)
     begin
       file_bucket_file = Puppet::FileBucket::File.new(contents, :bucket_path => @local_path)
       files_original_path = absolutize_path(file)
@@ -64,7 +64,7 @@ class Puppet::FileBucket::Dipper
   def restore(file,sum)
     restore = true
     if FileTest.exists?(file)
-      cursum = Digest::MD5.hexdigest(Puppet::Util.binread(file))
+      cursum = Digest::MD5.hexdigest(IO.binread(file))
 
       # if the checksum has changed...
       # this might be extra effort

data/lib/puppet/file_serving/base.rb

@@ -1,4 +1,5 @@
 require 'puppet/file_serving'
+require 'puppet/util'
 
 # The base class for Content and Metadata; provides common
 # functionality like the behaviour around links.
@@ -49,10 +50,7 @@ class Puppet::FileServing::Base
   # Set our base path.
   attr_reader :path
   def path=(path)
-    unless path =~ /^#{::File::SEPARATOR}/ or path =~ /^[a-z]:[\/\\]/i
-      raise ArgumentError.new("Paths must be fully qualified")
-    end
-
+    raise ArgumentError.new("Paths must be fully qualified") unless Puppet::FileServing::Base.absolute?(path)
     @path = path
   end
 
@@ -60,7 +58,7 @@ class Puppet::FileServing::Base
   # the file's path relative to the initial recursion point.
   attr_reader :relative_path
   def relative_path=(path)
-    raise ArgumentError.new("Relative paths must not be fully qualified") if path =~ /^#{::File::SEPARATOR}/
+    raise ArgumentError.new("Relative paths must not be fully qualified") if Puppet::FileServing::Base.absolute?(path)
     @relative_path = path
   end
 
@@ -84,4 +82,7 @@ class Puppet::FileServing::Base
     }
   end
 
+  def self.absolute?(path)
+    Puppet::Util.absolute_path?(path, :posix) or (Puppet.features.microsoft_windows? and Puppet::Util.absolute_path?(path, :windows))
+  end
 end

data/lib/puppet/file_serving/configuration/parser.rb

@@ -15,7 +15,7 @@ class Puppet::FileServing::Configuration::Parser < Puppet::Util::LoadedFile
 
     File.open(self.file) { |f|
       mount = nil
-      f.each { |line|
+      f.each_line { |line|
         # Have the count increment at the top, in case we throw exceptions.
         @count += 1
 

data/lib/puppet/file_serving/content.rb

@@ -35,7 +35,7 @@ class Puppet::FileServing::Content < Puppet::FileServing::Base
       # This stat can raise an exception, too.
       raise(ArgumentError, "Cannot read the contents of links unless following links") if stat.ftype == "symlink"
 
-      @content = Puppet::Util.binread(full_path)
+      @content = IO.binread(full_path)
     end
     @content
   end

data/lib/puppet/forge.rb

@@ -0,0 +1,153 @@
+require 'net/http'
+require 'open-uri'
+require 'pathname'
+require 'uri'
+require 'puppet/forge/cache'
+require 'puppet/forge/repository'
+
+module Puppet::Forge
+  class Forge
+    def initialize(url=Puppet.settings[:module_repository])
+      @uri = URI.parse(url)
+    end
+
+    # Return a list of module metadata hashes that match the search query.
+    # This return value is used by the module_tool face install search,
+    # and displayed to on the console.
+    #
+    # Example return value:
+    #
+    # [
+    #   {
+    #     "author"      => "puppetlabs",
+    #     "name"        => "bacula",
+    #     "tag_list"    => ["backup", "bacula"],
+    #     "releases"    => [{"version"=>"0.0.1"}, {"version"=>"0.0.2"}],
+    #     "full_name"   => "puppetlabs/bacula",
+    #     "version"     => "0.0.2",
+    #     "project_url" => "http://github.com/puppetlabs/puppetlabs-bacula",
+    #     "desc"        => "bacula"
+    #   }
+    # ]
+    #
+    def search(term)
+      request = Net::HTTP::Get.new("/modules.json?q=#{URI.escape(term)}")
+      response = repository.make_http_request(request)
+
+      case response.code
+      when "200"
+        matches = PSON.parse(response.body)
+      else
+        raise RuntimeError, "Could not execute search (HTTP #{response.code})"
+        matches = []
+      end
+
+      matches
+    end
+
+    # Return a Pathname object representing the path to the module
+    # release package in the `Puppet.settings[:module_working_dir]`.
+    def get_release_package(params)
+      cache_path = nil
+      case params[:source]
+      when :repository
+        if not (params[:author] && params[:modname])
+          raise ArgumentError, ":author and :modename required"
+        end
+        cache_path = get_release_package_from_repository(params[:author], params[:modname], params[:version])
+      when :filesystem
+        if not params[:filename]
+          raise ArgumentError, ":filename required"
+        end
+        cache_path = get_release_package_from_filesystem(params[:filename])
+      else
+        raise ArgumentError, "Could not determine installation source"
+      end
+
+      cache_path
+    end
+
+    def get_releases(author, modname)
+      request_string = "/#{author}/#{modname}"
+
+      begin
+        response = repository.make_http_request(request_string)
+      rescue => e
+        raise ArgumentError, "Could not find a release for this module (#{e.message})"
+      end
+
+      results = PSON.parse(response.body)
+      # At this point releases look like this:
+      # [{"version" => "0.0.1"}, {"version" => "0.0.2"},{"version" => "0.0.3"}]
+      #
+      # Lets fix this up a bit and return something like this to the caller
+      # ["0.0.1", "0.0.2", "0.0.3"]
+      results["releases"].collect {|release| release["version"]}
+    end
+
+    private
+
+    # Locate and download a module release package from the remote forge
+    # repository into the `Puppet.settings[:module_working_dir]`. Do not
+    # unpack it, just return the location of the package on disk.
+    def get_release_package_from_repository(author, modname, version=nil)
+      release = get_release(author, modname, version)
+      if release['file']
+        begin
+          cache_path = repository.retrieve(release['file'])
+        rescue OpenURI::HTTPError => e
+          raise RuntimeError, "Could not download module: #{e.message}"
+        end
+      else
+        raise RuntimeError, "Malformed response from module repository."
+      end
+
+      cache_path
+    end
+
+    # Locate a module release package on the local filesystem and move it
+    # into the `Puppet.settings[:module_working_dir]`. Do not unpack it, just
+    # return the location of the package on disk.
+    def get_release_package_from_filesystem(filename)
+      if File.exist?(File.expand_path(filename))
+        repository = Repository.new('file:///')
+        uri = URI.parse("file://#{URI.escape(File.expand_path(filename))}")
+        cache_path = repository.retrieve(uri)
+      else
+        raise ArgumentError, "File does not exists: #{filename}"
+      end
+
+      cache_path
+    end
+
+    def repository
+      @repository ||= Puppet::Forge::Repository.new(@uri)
+    end
+
+    # Connect to the remote repository and locate a specific module release
+    # by author/name combination. If a version requirement is specified, search
+    # for that exact version, or grab the latest release available.
+    #
+    # Return the following response to the caller:
+    #
+    # {"file"=>"/system/releases/p/puppetlabs/puppetlabs-apache-0.0.3.tar.gz", "version"=>"0.0.3"}
+    #
+    #
+    def get_release(author, modname, version_requirement=nil)
+      request_string = "/users/#{author}/modules/#{modname}/releases/find.json"
+      if version_requirement
+        request_string + "?version=#{URI.escape(version_requirement)}"
+      end
+      request = Net::HTTP::Get.new(request_string)
+
+      begin
+        response = repository.make_http_request(request)
+      rescue => e
+        raise  ArgumentError, "Could not find a release for this module (#{e.message})"
+      end
+
+      PSON.parse(response.body)
+    end
+  end
+end
+