puppet 2.7.13 → 2.7.14

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

@@ -1,8 +1,11 @@
+require 'puppet/util/terminal'
+
 Puppet::Face.define(:module, '1.0.0') do
   action(:search) do
     summary "Search a repository for a module."
     description <<-EOT
-      Search a repository for modules whose names match a specific substring.
+      Searches a repository for modules whose names, descriptions, or keywords
+      match the provided search term.
     EOT
 
     returns "Array of module metadata hashes"
@@ -15,41 +18,71 @@ Puppet::Face.define(:module, '1.0.0') do
       bacula        This is a generic Apache module      @puppetlabs        backups
     EOT
 
-    arguments "<term>"
-
-    option "--module-repository=", "-r=" do
-      default_to { Puppet.settings[:module_repository] }
-      summary "Module repository to use."
-      description <<-EOT
-        Module repository to use.
-      EOT
-    end
+    arguments "<search_term>"
 
     when_invoked do |term, options|
-      Puppet::Module::Tool::Applications::Searcher.run(term, options)
+      Puppet::ModuleTool::Applications::Searcher.run(term, options)
     end
 
-    when_rendering :console do |return_value|
+    when_rendering :console do |results, term, options|
+      return "No results found for '#{term}'." if results.empty?
+
+      padding = '  '
+      headers = {
+        'full_name' => 'NAME',
+        'desc'      => 'DESCRIPTION',
+        'author'    => 'AUTHOR',
+        'tag_list'  => 'KEYWORDS',
+      }
 
-      FORMAT = "%-10s    %-32s     %-14s     %s\n"
+      min_widths = Hash[ *headers.map { |k,v| [k, v.length] }.flatten ]
+      min_widths['full_name'] = min_widths['author'] = 12
 
-      def header
-        FORMAT % ['NAME', 'DESCRIPTION', 'AUTHOR', 'KEYWORDS']
+      min_width = min_widths.inject(0) { |sum,pair| sum += pair.last } + (padding.length * (headers.length - 1))
+
+      terminal_width = [Puppet::Util::Terminal.width, min_width].max
+
+      columns = results.inject(min_widths) do |hash, result|
+        {
+          'full_name' => [ hash['full_name'], result['full_name'].length          ].max,
+          'desc'      => [ hash['desc'],      result['desc'].length               ].max,
+          'author'    => [ hash['author'],    "@#{result['author']}".length       ].max,
+          'tag_list'  => [ hash['tag_list'],  result['tag_list'].join(' ').length ].max,
+        }
       end
 
-      def format_row(name, description, author, tag_list)
-        keywords = tag_list.join(' ')
-        FORMAT % [name[0..10], description[0..32], "@#{author[0..14]}", keywords]
+      flex_width = terminal_width - columns['full_name'] - columns['author'] - (padding.length * (headers.length - 1))
+      tag_lists = results.map { |r| r['tag_list'] }
+
+      while (columns['tag_list'] > flex_width / 3)
+        longest_tag_list = tag_lists.sort_by { |tl| tl.join(' ').length }.last
+        break if [ [], [term] ].include? longest_tag_list
+        longest_tag_list.delete(longest_tag_list.sort_by { |t| t == term ? -1 : t.length }.last)
+        columns['tag_list'] =  tag_lists.map { |tl| tl.join(' ').length }.max
       end
 
-      output = ''
-      output << header unless return_value.empty?
+      columns['tag_list'] = [
+        flex_width / 3,
+        tag_lists.map { |tl| tl.join(' ').length }.max,
+      ].max
+      columns['desc'] = flex_width - columns['tag_list']
+
+      format = %w{full_name desc author tag_list}.map do |k|
+        "%-#{ [ columns[k], min_widths[k] ].max }s"
+      end.join(padding) + "\n"
 
-      return_value.map do |match|
-        output << format_row(match['name'], match['desc'], match['author'], match['tag_list'])
+      highlight = proc do |s|
+        s = s.gsub(term, colorize(:green, term))
+        s = s.gsub(term.gsub('/', '-'), colorize(:green, term.gsub('/', '-'))) if term =~ /\//
+        s
       end
 
-      output
+      format % [ headers['full_name'], headers['desc'], headers['author'], headers['tag_list'] ] +
+      results.map do |match|
+        name, desc, author, keywords = %w{full_name desc author tag_list}.map { |k| match[k] }
+        desc = desc[0...(columns['desc'] - 3)] + '...' if desc.length > columns['desc']
+        highlight[format % [ name.sub('/', '-'), desc, "@#{author}", [keywords].flatten.join(' ') ]]
+      end.join
     end
   end
 end

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

@@ -2,50 +2,57 @@ Puppet::Face.define(:module, '1.0.0') do
   action(:uninstall) do
     summary "Uninstall a puppet module."
     description <<-EOT
-      Uninstall a puppet module from the modulepath or a specific
-      target directory which defaults to
-      #{Puppet.settings[:modulepath].split(File::PATH_SEPARATOR).join(', ')}.
+      Uninstalls a puppet module from the modulepath (or a specific
+      target directory).
     EOT
 
     returns "Hash of module objects representing uninstalled modules and related errors."
 
     examples <<-EOT
-      Uninstall a module from all directories in the modulepath:
+      Uninstall a module:
 
-      $ puppet module uninstall ssh
+      $ puppet module uninstall puppetlabs-ssh
       Removed /etc/puppet/modules/ssh (v1.0.0)
 
       Uninstall a module from a specific directory:
 
-      $ puppet module uninstall --modulepath /usr/share/puppet/modules ssh
+      $ puppet module uninstall puppetlabs-ssh --modulepath /usr/share/puppet/modules
       Removed /usr/share/puppet/modules/ssh (v1.0.0)
 
       Uninstall a module from a specific environment:
 
-      $ puppet module uninstall --environment development 
+      $ puppet module uninstall puppetlabs-ssh --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
+      $ puppet module uninstall puppetlabs-ssh --version 2.0.0
       Removed /etc/puppet/modules/ssh (v2.0.0)
     EOT
 
     arguments "<name>"
 
-    option "--environment=NAME", "--env=NAME" do
+    option "--force", "-f" do
+      summary "Force uninstall of an installed module."
+      description <<-EOT
+        Force the uninstall of an installed module even if there are local
+        changes or the possibility of causing broken dependencies.
+      EOT
+    end
+
+    option "--environment NAME" do
       default_to { "production" }
-      summary "The target environment to search for modules."
+      summary "The target environment to uninstall modules from."
       description <<-EOT
-        The target environment to search for modules.
+        The target environment to uninstall modules from.
       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.
+        The version of the module to uninstall. When using this option, a module
+        matching the specified version must be installed or else an error is raised.
       EOT
     end
 
@@ -57,35 +64,23 @@ Puppet::Face.define(:module, '1.0.0') do
     end
 
     when_invoked do |name, options|
-      if options[:modulepath]
-        unless File.directory?(options[:modulepath])
-          raise ArgumentError, "Directory #{options[:modulepath]} does not exist"
-        end
-      end
-
       Puppet[:modulepath] = options[:modulepath] if options[:modulepath]
-      options[:name] = name
+      name = name.gsub('/', '-')
 
-      Puppet::Module::Tool::Applications::Uninstaller.run(name, options)
+      Puppet.notice "Preparing to uninstall '#{name}'" << (options[:version] ? " (#{colorize(:cyan, options[:version].sub(/^(?=\d)/, 'v'))})" : '') << " ..."
+      Puppet::ModuleTool::Applications::Uninstaller.run(name, options)
     end
 
     when_rendering :console do |return_value|
-      output = ''
-
-      return_value[:removed_mods].each do |mod| 
-        output << "Removed #{mod.path} (v#{mod.version})\n"
+      if return_value[:result] == :failure
+        Puppet.err(return_value[:error][:multiline])
+        exit 1
+      else
+        mod = return_value[:affected_modules].first
+        "Removed '#{return_value[:module_name]}'" <<
+        (mod.version ? " (#{colorize(:cyan, mod.version.to_s.sub(/^(?=\d)/, 'v'))})" : '') <<
+        " from #{mod.modulepath}"
       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/face/module/upgrade.rb

@@ -0,0 +1,84 @@
+# encoding: UTF-8
+
+Puppet::Face.define(:module, '1.0.0') do
+  action(:upgrade) do
+    summary "Upgrade a puppet module."
+    description <<-EOT
+      Upgrades a puppet module.
+    EOT
+
+    returns "Hash"
+
+    examples <<-EOT
+      upgrade an installed module to the latest version
+
+      $ puppet module upgrade puppetlabs-apache
+      /etc/puppet/modules
+      └── puppetlabs-apache (v1.0.0 -> v2.4.0)
+
+      upgrade an installed module to a specific version
+
+      $ puppet module upgrade puppetlabs-apache --version 2.1.0
+      /etc/puppet/modules
+      └── puppetlabs-apache (v1.0.0 -> v2.1.0)
+
+      upgrade an installed module for a specific environment
+
+      $ puppet module upgrade puppetlabs-apache --environment test
+      /usr/share/puppet/environments/test/modules
+      └── puppetlabs-apache (v1.0.0 -> v2.4.0)
+    EOT
+
+    arguments "<name>"
+
+    option "--force", "-f" do
+      summary "Force upgrade of an installed module."
+      description <<-EOT
+        Force the upgrade of an installed module even if there are local
+        changes or the possibility of causing broken dependencies.
+      EOT
+    end
+
+    option "--ignore-dependencies" do
+      summary "Do not attempt to install dependencies."
+      description <<-EOT
+        Do not attempt to install dependencies
+      EOT
+    end
+
+    option "--environment 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 upgrade to."
+      description <<-EOT
+        The version of the module to upgrade to.
+      EOT
+    end
+
+    when_invoked do |name, options|
+      name = name.gsub('/', '-')
+      Puppet.notice "Preparing to upgrade '#{name}' ..."
+      Puppet::ModuleTool::Applications::Upgrader.new(name, options).run
+    end
+
+    when_rendering :console do |return_value|
+      if return_value[:result] == :failure
+        Puppet.err(return_value[:error][:multiline])
+        exit 1
+      elsif return_value[:result] == :noop
+        Puppet.err(return_value[:error][:multiline])
+        exit 0
+      else
+        tree = Puppet::ModuleTool.build_tree(return_value[:affected_modules], return_value[:base_dir])
+        return_value[:base_dir] + "\n" +
+        Puppet::ModuleTool.format_tree(tree)
+      end
+    end
+  end
+end

data/lib/puppet/feature/eventlog.rb

@@ -0,0 +1,6 @@
+require 'puppet/util/feature'
+
+if Puppet.features.microsoft_windows?
+  Puppet.features.rubygems?
+  Puppet.features.add(:eventlog, :libs => %{win32/eventlog})
+end

data/lib/puppet/forge.rb

@@ -6,148 +6,93 @@ require 'puppet/forge/cache'
 require 'puppet/forge/repository'
 
 module Puppet::Forge
-  class Forge
-    def initialize(url=Puppet.settings[:module_repository])
-      @uri = URI.parse(url)
+  # 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 self.search(term)
+    server = Puppet.settings[:module_repository].sub(/^(?!https?:\/\/)/, 'http://')
+    Puppet.notice "Searching #{server} ..."
+    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
 
-    # 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)
+    matches
+  end
 
-      case response.code
-      when "200"
-        matches = PSON.parse(response.body)
+  def self.remote_dependency_info(author, mod_name, version)
+    version_string = version ? "&version=#{version}" : ''
+    request = Net::HTTP::Get.new("/api/v1/releases.json?module=#{author}/#{mod_name}" + version_string)
+    response = repository.make_http_request(request)
+    json = PSON.parse(response.body) rescue {}
+    case response.code
+    when "200"
+      return json
+    else
+      error = json['error'] || ''
+      if error =~ /^Module #{author}\/#{mod_name} has no release/
+        return []
       else
-        raise RuntimeError, "Could not execute search (HTTP #{response.code})"
-        matches = []
+        raise RuntimeError, "Could not find release information for this module (#{author}/#{mod_name}) (HTTP #{response.code})"
       end
-
-      matches
     end
+  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)
+  def self.get_release_packages_from_repository(install_list)
+    install_list.map do |release|
+      modname, version, file = release
       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']
+      if file
         begin
-          cache_path = repository.retrieve(release['file'])
+          cache_path = repository.retrieve(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
+  end
 
-    def repository
-      @repository ||= Puppet::Forge::Repository.new(@uri)
+  # 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 self.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
 
-    # 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
+    cache_path
+  end
 
-      PSON.parse(response.body)
-    end
+  def self.repository
+    @repository ||= Puppet::Forge::Repository.new
   end
 end
-