puppet 2.7.13 → 2.7.14

data/lib/puppet/defaults.rb

@@ -15,7 +15,7 @@ module Puppet
   setdefaults(:main,
     :trace => [false, "Whether to print stack traces on some errors"],
     :autoflush => {
-      :default => false,
+      :default => true,
       :desc    => "Whether log files should always flush to disk.",
       :hook    => proc { |value| Log.autoflush = value }
     },

data/lib/puppet/face/certificate.rb

@@ -103,7 +103,7 @@ Puppet::Indirector::Face.define(:certificate, '0.0.1') do
 
     when_invoked do |name, options|
       host = Puppet::SSL::Host.new(name)
-      if options[:ca_location] == :remote
+      if Puppet::SSL::Host.ca_location == :remote
         if options[:allow_dns_alt_names]
           raise ArgumentError, "--allow-dns-alt-names may not be specified with a remote CA"
         end

data/lib/puppet/face/help/man.erb

@@ -71,7 +71,7 @@ ACTIONS
 
 <%     unique_options.sort.each do |name|
          option = action.get_option name
-         text = option.description || option.summary -%>
+         text = (option.description || option.summary).chomp + "\n" -%>
   <%= '<' + option.optparse.join("> | <") + '>' %> -
 <%= text.gsub(/^/, '  ') %>
 <%     end -%>

data/lib/puppet/face/module.rb

@@ -0,0 +1,17 @@
+require 'puppet/face'
+require 'puppet/module_tool'
+require 'puppet/util/colors'
+
+Puppet::Face.define(:module, '1.0.0') do
+  extend Puppet::Util::Colors
+
+  copyright "Puppet Labs", 2012
+  license   "Apache 2 license; see COPYING"
+
+  summary "Creates, installs and searches for modules on the Puppet Forge."
+  description <<-EOT
+    This subcommand can find, install, and manage modules from the Puppet Forge,
+    a repository of user-contributed Puppet code. It can also generate empty
+    modules, and prepare locally developed modules for release on the Forge.
+  EOT
+end

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

@@ -2,9 +2,15 @@ Puppet::Face.define(:module, '1.0.0') do
   action(:build) do
     summary "Build a module release package."
     description <<-EOT
-      Build a module release archive file by processing the Modulefile in the
-      module directory.  The release archive file will be stored in the pkg
-      directory of the module directory.
+      Prepares a local module for release on the Puppet Forge by building a
+      ready-to-upload archive file.
+
+      This action uses the Modulefile in the module directory to set metadata
+      used by the Forge. See <http://links.puppetlabs.com/modulefile> for more
+      about writing modulefiles.
+
+      After being built, the release archive file can be found in the module's
+      `pkg` directory.
     EOT
 
     returns "Pathname object representing the path to the release archive."
@@ -20,7 +26,7 @@ Puppet::Face.define(:module, '1.0.0') do
     arguments "<path>"
 
     when_invoked do |path, options|
-      Puppet::Module::Tool::Applications::Builder.run(path, options)
+      Puppet::ModuleTool::Applications::Builder.run(path, options)
     end
 
     when_rendering :console do |return_value|

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

@@ -2,9 +2,9 @@ Puppet::Face.define(:module, '1.0.0') do
   action(:changes) do
     summary "Show modified files of an installed module."
     description <<-EOT
-      Show files that have been modified after installation of a given module
-      by comparing the on-disk md5 checksum of each file against the module's
-      metadata.
+      Shows any files in a module that have been modified since it was
+      installed. This action compares the files on disk to the md5 checksums
+      included in the module's metadata.
     EOT
 
     returns "Array of strings representing paths of modified files."
@@ -20,8 +20,8 @@ Puppet::Face.define(:module, '1.0.0') do
     arguments "<path>"
 
     when_invoked do |path, options|
-      root_path = Puppet::Module::Tool.find_module_root(path)
-      Puppet::Module::Tool::Applications::Checksummer.run(root_path, options)
+      root_path = Puppet::ModuleTool.find_module_root(path)
+      Puppet::ModuleTool::Applications::Checksummer.run(root_path, options)
     end
 
     when_rendering :console do |return_value|

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

@@ -2,9 +2,11 @@ Puppet::Face.define(:module, '1.0.0') do
   action(:generate) do
     summary "Generate boilerplate for a new module."
     description <<-EOT
-      Generate boilerplate for a new module by creating a directory
-      pre-populated with a directory structure and files recommended for
-      Puppet best practices.
+      Generates boilerplate for a new module by creating the directory
+      structure and files recommended for the Puppet community's best practices.
+
+      A module may need additional directories beyond this boilerplate
+      if it provides plugins, files, or templates.
     EOT
 
     returns "Array of Pathname objects representing paths of generated files."
@@ -30,7 +32,7 @@ Puppet::Face.define(:module, '1.0.0') do
     arguments "<name>"
 
     when_invoked do |name, options|
-      Puppet::Module::Tool::Applications::Generator.run(name, options)
+      Puppet::ModuleTool::Applications::Generator.run(name, options)
     end
 
     when_rendering :console do |return_value|

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

@@ -1,39 +1,82 @@
+# encoding: UTF-8
+
 Puppet::Face.define(:module, '1.0.0') do
   action(:install) do
     summary "Install a module from a repository or release archive."
     description <<-EOT
-      Install a module from a release archive file on-disk or by downloading
-      one from a repository. Unpack the archive into the install directory
-      specified by the --install-dir option, which defaults to
-      #{Puppet.settings[:modulepath].split(File::PATH_SEPARATOR).first}
+      Installs a module from the Puppet Forge, from a release archive file
+      on-disk, or from a private Forge-like repository.
+
+      The specified module will be installed into the directory
+      specified with the `--target-dir` option, which defaults to
+      #{Puppet.settings[:modulepath].split(File::PATH_SEPARATOR).first}.
     EOT
 
     returns "Pathname object representing the path to the installed module."
 
     examples <<-EOT
-      Install a module from the default repository:
+      Install a module:
+
+      $ puppet module install puppetlabs-vcsrepo
+      Preparing to install into /etc/puppet/modules ...
+      Downloading from http://forge.puppetlabs.com ...
+      Installing -- do not interrupt ...
+      /etc/puppet/modules
+      └── puppetlabs-vcsrepo (v0.0.4)
 
-      $ puppet module install puppetlabs/vcsrepo
-      notice: Installing puppetlabs-vcsrepo-0.0.4.tar.gz to /etc/puppet/modules/vcsrepo
-      /etc/puppet/modules/vcsrepo
+      Install a module to a specific environment:
 
-      Install a specific module version from a repository:
+      $ puppet module install puppetlabs-vcsrepo --environment development
+      Preparing to install into /etc/puppet/environments/development/modules ...
+      Downloading from http://forge.puppetlabs.com ...
+      Installing -- do not interrupt ...
+      /etc/puppet/environments/development/modules
+      └── puppetlabs-vcsrepo (v0.0.4)
 
-      $ puppet module install puppetlabs/vcsrepo -v 0.0.4
-      notice: Installing puppetlabs-vcsrepo-0.0.4.tar.gz to /etc/puppet/modules/vcsrepo
-      /etc/puppet/modules/vcsrepo
+      Install a specific module version:
+
+      $ puppet module install puppetlabs-vcsrepo -v 0.0.4
+      Preparing to install into /etc/puppet/modules ...
+      Downloading from http://forge.puppetlabs.com ...
+      Installing -- do not interrupt ...
+      /etc/puppet/modules
+      └── puppetlabs-vcsrepo (v0.0.4)
 
       Install a module into a specific directory:
 
-      $ puppet module install puppetlabs/vcsrepo --install-dir=/usr/share/puppet/modules
-      notice: Installing puppetlabs-vcsrepo-0.0.4.tar.gz to /usr/share/puppet/modules/vcsrepo
-      /usr/share/puppet/modules/vcsrepo
+      $ puppet module install puppetlabs-vcsrepo --target-dir=/usr/share/puppet/modules
+      Preparing to install into /usr/share/puppet/modules ...
+      Downloading from http://forge.puppetlabs.com ...
+      Installing -- do not interrupt ...
+      /usr/share/puppet/modules
+      └── puppetlabs-vcsrepo (v0.0.4)
+
+      Install a module into a specific directory and check for dependencies in other directories:
+
+      $ puppet module install puppetlabs-vcsrepo --target-dir=/usr/share/puppet/modules --modulepath /etc/puppet/modules
+      Preparing to install into /usr/share/puppet/modules ...
+      Downloading from http://forge.puppetlabs.com ...
+      Installing -- do not interrupt ...
+      /usr/share/puppet/modules
+      └── puppetlabs-vcsrepo (v0.0.4)
 
       Install a module from a release archive:
 
       $ puppet module install puppetlabs-vcsrepo-0.0.4.tar.gz
-      notice: Installing puppetlabs-vcsrepo-0.0.4.tar.gz to /etc/puppet/modules/vcsrepo
-      /etc/puppet/modules/vcsrepo
+      Preparing to install into /etc/puppet/modules ...
+      Downloading from http://forge.puppetlabs.com ...
+      Installing -- do not interrupt ...
+      /etc/puppet/modules
+      └── puppetlabs-vcsrepo (v0.0.4)
+
+      Install a module from a release archive and ignore dependencies:
+
+      $ puppet module install puppetlabs-vcsrepo-0.0.4.tar.gz --ignore-dependencies
+      Preparing to install into /etc/puppet/modules ...
+      Installing -- do not interrupt ...
+      /etc/puppet/modules
+      └── puppetlabs-vcsrepo (v0.0.4)
+
     EOT
 
     arguments "<name>"
@@ -45,39 +88,86 @@ Puppet::Face.define(:module, '1.0.0') do
       EOT
     end
 
-    option "--install-dir=", "-i=" do
-      default_to { Puppet.settings[:modulepath].split(File::PATH_SEPARATOR).first }
+    option "--target-dir DIR", "-i DIR" do
       summary "The directory into which modules are installed."
       description <<-EOT
-        The directory into which modules are installed, defaults to the first
+        The directory into which modules are installed; defaults to the first
         directory in the modulepath.
+
+        Specifying this option will change the installation directory, and
+        will use the existing modulepath when checking for dependencies. If
+        you wish to check a different set of directories for dependencies, you
+        must also use the `--environment` or `--modulepath` options.
       EOT
     end
 
-    option "--module-repository=", "-r=" do
-      default_to { Puppet.settings[:module_repository] }
-      summary "Module repository to use."
+    option "--ignore-dependencies" do
+      summary "Do not attempt to install dependencies"
       description <<-EOT
-        Module repository to use.
+        Do not attempt to install dependencies.
       EOT
     end
 
-    option "--version=", "-v=" do
+    option "--modulepath MODULEPATH" do
+      default_to { Puppet.settings[:modulepath] }
+      summary "Which directories to look for modules in"
+      description <<-EOT
+        The list of directories to check for modules. When installing a new
+        module, this setting determines where the module tool will look for
+        its dependencies. If the `--target dir` option is not specified, the
+        first directory in the modulepath will also be used as the install
+        directory.
+
+        When installing a module into an environment whose modulepath is
+        specified in puppet.conf, you can use the `--environment` option
+        instead, and its modulepath will be used automatically.
+
+        This setting should be a list of directories separated by the path
+        separator character. (The path separator is `:` on Unix-like platforms
+        and `;` on Windows.)
+      EOT
+    end
+
+    option "--version VER", "-v VER" do
       summary "Module version to install."
       description <<-EOT
-        Module version to install, can be a requirement string, eg '>= 1.0.3',
-        defaults to latest version.
+        Module version to install; can be an exact version or a requirement string,
+        eg '>= 1.0.3'. Defaults to latest version.
+      EOT
+    end
+
+    option "--environment NAME" do
+      default_to { "production" }
+      summary "The target environment to install modules into."
+      description <<-EOT
+        The target environment to install modules into. Only applicable if
+        multiple environments (with different modulepaths) have been
+        configured in puppet.conf.
       EOT
     end
 
     when_invoked do |name, options|
-      Puppet::Module::Tool::Applications::Installer.run(name, options)
+      sep = File::PATH_SEPARATOR
+      if options[:target_dir]
+        options[:modulepath] = "#{options[:target_dir]}#{sep}#{options[:modulepath]}"
+      end
+
+      Puppet.settings[:modulepath] = options[:modulepath]
+      options[:target_dir] = Puppet.settings[:modulepath].split(sep).first
+
+      Puppet.notice "Preparing to install into #{options[:target_dir]} ..."
+      Puppet::ModuleTool::Applications::Installer.run(name, options)
     end
 
-    when_rendering :console do |return_value|
-      # Get the string representation of the Pathname object and print it to
-      # the console.
-      return_value.to_s
+    when_rendering :console do |return_value, name, options|
+      if return_value[:result] == :failure
+        Puppet.err(return_value[:error][:multiline])
+        exit 1
+      else
+        tree = Puppet::ModuleTool.build_tree(return_value[:installed_modules], return_value[:install_dir])
+        return_value[:install_dir] + "\n" +
+        Puppet::ModuleTool.format_tree(tree)
+      end
     end
   end
 end

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

@@ -1,21 +1,37 @@
+# encoding: UTF-8
+
 Puppet::Face.define(:module, '1.0.0') do
   action(:list) 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.  The output will
-      include information about unmet module dependencies based on information
-      from module metadata.
-      #{Puppet.settings[:modulepath]}
+      Lists the installed puppet modules. By default, this action scans the
+      modulepath from puppet.conf's `[main]` block; use the --modulepath
+      option to change which directories are scanned.
+
+      The output of this action includes information from the module's
+      metadata, including version numbers and unmet module dependencies.
     HEREDOC
     returns "hash of paths to module objects"
 
-    option "--env ENVIRONMENT" do
+    option "--environment NAME" do
+      default_to { "production" }
       summary "Which environments' modules to list"
+      description <<-EOT
+        Which environments' modules to list.
+      EOT
     end
 
     option "--modulepath MODULEPATH" do
       summary "Which directories to look for modules in"
+      description <<-EOT
+        Which directories to look for modules in; use the system path separator
+        character (`:` on Unix-like systems and `;` on Windows) to specify
+        multiple directories.
+      EOT
+    end
+
+    option "--tree" do
+      summary "Whether to show dependencies as a tree view"
     end
 
     examples <<-EOT
@@ -23,32 +39,44 @@ Puppet::Face.define(:module, '1.0.0') do
 
       $ puppet module list
         /etc/puppet/modules
-          bacula (0.0.2)
-        /usr/share/puppet/modules
-          apache (0.0.3)
-          bacula (0.0.1)
+        ├── bodepd-create_resources (v0.0.1)
+        ├── puppetlabs-bacula (v0.0.2)
+        ├── puppetlabs-mysql (v0.0.1)
+        ├── puppetlabs-sqlite (v0.0.1)
+        └── puppetlabs-stdlib (v2.2.1)
+        /usr/share/puppet/modules (no modules installed)
 
-      List installed modules from a specified environment:
+      List installed modules in a tree view:
 
-      $ puppet module list --env 'test'
-        Missing dependency `stdlib`:
-          `rrd` (0.0.2) requires `puppetlabs/stdlib` (>= 2.2.0)
+      $ puppet module list --tree
+        /etc/puppet/modules
+        └─┬ puppetlabs-bacula (v0.0.2)
+          ├── puppetlabs-stdlib (v2.2.1)
+          ├─┬ puppetlabs-mysql (v0.0.1)
+          │ └── bodepd-create_resources (v0.0.1)
+          └── puppetlabs-sqlite (v0.0.1)
+        /usr/share/puppet/modules (no modules installed)
+
+      List installed modules from a specified environment:
 
-        /tmp/puppet/modules
-          rrd (0.0.2)
+      $ puppet module list --environment production
+        /etc/puppet/modules
+        ├── bodepd-create_resources (v0.0.1)
+        ├── puppetlabs-bacula (v0.0.2)
+        ├── puppetlabs-mysql (v0.0.1)
+        ├── puppetlabs-sqlite (v0.0.1)
+        └── puppetlabs-stdlib (v2.2.1)
+        /usr/share/puppet/modules (no modules installed)
 
       List installed modules from a specified modulepath:
 
-      $ puppet module list --modulepath /tmp/facts1:/tmp/facts2
-        /tmp/facts1
-          stdlib
-        /tmp/facts2
-          nginx (1.0.0)
+      $ puppet module list --modulepath /usr/share/puppet/modules
+        /usr/share/puppet/modules (no modules installed)
     EOT
 
     when_invoked do |options|
       Puppet[:modulepath] = options[:modulepath] if options[:modulepath]
-      environment = Puppet::Node::Environment.new(options[:env])
+      environment = Puppet::Node::Environment.new(options[:environment])
 
       environment.modules_by_path
     end
@@ -57,28 +85,201 @@ Puppet::Face.define(:module, '1.0.0') do
       output = ''
 
       Puppet[:modulepath] = options[:modulepath] if options[:modulepath]
-      environment = Puppet::Node::Environment.new(options[:env])
+      environment = Puppet::Node::Environment.new(options[:production])
 
-      dependency_errors = false
+      error_types = {
+        :non_semantic_version => {
+          :title => "Non semantic version dependency"
+        },
+        :missing => {
+          :title => "Missing dependency"
+        },
+        :version_mismatch => {
+          :title => "Module '%s' (v%s) fails to meet some dependencies:"
+        }
+      }
 
+      @unmet_deps = {}
+      error_types.each_key do |type|
+        @unmet_deps[type] = Hash.new do |hash, key|
+          hash[key] = { :errors => [], :parent => nil }
+        end
+      end
+
+      # Prepare the unmet dependencies for display on the console.
       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]
+        unmet_grouped = Hash.new { |h,k| h[k] = [] }
+        unmet_grouped = mod.unmet_dependencies.inject(unmet_grouped) do |acc, dep|
+          acc[dep[:reason]] << dep
+          acc
+        end
+        unmet_grouped.each do |type, deps|
+          unless deps.empty?
+            unmet_grouped[type].sort_by { |dep| dep[:name] }.each do |dep|
+              dep_name           = dep[:name].gsub('/', '-')
+              installed_version  = dep[:mod_details][:installed_version]
+              version_constraint = dep[:version_constraint]
+              parent_name        = dep[:parent][:name].gsub('/', '-')
+              parent_version     = dep[:parent][:version]
+
+              msg = "'#{parent_name}' (#{parent_version})"
+              msg << " requires '#{dep_name}' (#{version_constraint})"
+              @unmet_deps[type][dep[:name]][:errors] << msg
+              @unmet_deps[type][dep[:name]][:parent] = {
+                :name    => dep[:parent][:name],
+                :version => parent_version
+              }
+              @unmet_deps[type][dep[:name]][:version] = installed_version
+            end
+          end
+        end
+      end
+
+      # Display unmet dependencies by category.
+      error_display_order = [:non_semantic_version, :version_mismatch, :missing]
+      error_display_order.each do |type|
+        unless @unmet_deps[type].empty?
+          @unmet_deps[type].keys.sort_by {|dep| dep }.each do |dep|
+            name    = dep.gsub('/', '-')
+            title   = error_types[type][:title]
+            errors  = @unmet_deps[type][dep][:errors]
+            version = @unmet_deps[type][dep][:version]
+
+            msg = case type
+                  when :version_mismatch
+                    title % [name, version] + "\n"
+                  when :non_semantic_version
+                    title + " '#{name}' (v#{version}):\n"
+                  else
+                    title + " '#{name}':\n"
+                  end
+
+            errors.each { |error_string| msg << "  #{error_string}\n" }
+            Puppet.warning msg.chomp
+          end
         end
       end
 
-      output << "\n" if dependency_errors
+      environment.modulepath.each do |path|
+        modules = modules_by_path[path]
+        no_mods = modules.empty? ? ' (no modules installed)' : ''
+        output << "#{path}#{no_mods}\n"
 
-      modules_by_path.each do |path, modules|
-        output << "#{path}\n"
-        modules.sort_by {|mod| mod.name }.each do |mod|
-          version_string = mod.version ? "(#{mod.version})" : ''
-          output << "  #{mod.name} #{version_string}\n"
+        if options[:tree]
+          # The modules with fewest things depending on them will be the
+          # parent of the tree.  Can't assume to start with 0 dependencies
+          # since dependencies may be cyclical.
+          modules_by_num_requires = modules.sort_by {|m| m.required_by.size}
+          @seen = {}
+          tree = list_build_tree(modules_by_num_requires, [], nil,
+            :label_unmet => true, :path => path, :label_invalid => false)
+        else
+          tree = []
+          modules.sort_by { |mod| mod.forge_name or mod.name  }.each do |mod|
+            tree << list_build_node(mod, path, :label_unmet => false,
+                      :path => path, :label_invalid => true)
+          end
         end
+
+        output << Puppet::ModuleTool.format_tree(tree)
       end
+
       output
     end
+  end
+
+  # Prepare a list of module objects and their dependencies for print in a
+  # tree view.
+  #
+  # Returns an Array of Hashes
+  #
+  # Example:
+  #
+  #   [
+  #     {
+  #       :text => "puppetlabs-bacula (v0.0.2)",
+  #       :dependencies=> [
+  #         { :text => "puppetlabs-stdlib (v2.2.1)", :dependencies => [] },
+  #         {
+  #           :text => "puppetlabs-mysql (v1.0.0)"
+  #           :dependencies => [
+  #             {
+  #               :text => "bodepd-create_resources (v0.0.1)",
+  #               :dependencies => []
+  #             }
+  #           ]
+  #         },
+  #         { :text => "puppetlabs-sqlite (v0.0.1)", :dependencies => [] },
+  #       ]
+  #     }
+  #   ]
+  #
+  # When the above data structure is passed to Puppet::ModuleTool.build_tree
+  # you end up with something like this:
+  #
+  #   /etc/puppet/modules
+  #   └─┬ puppetlabs-bacula (v0.0.2)
+  #     ├── puppetlabs-stdlib (v2.2.1)
+  #     ├─┬ puppetlabs-mysql (v1.0.0)
+  #     │ └── bodepd-create_resources (v0.0.1)
+  #     └── puppetlabs-sqlite (v0.0.1)
+  #
+  def list_build_tree(list, ancestors=[], parent=nil, params={})
+    list.map do |mod|
+      next if @seen[(mod.forge_name or mod.name)]
+      node = list_build_node(mod, parent, params)
+      @seen[(mod.forge_name or mod.name)] = true
+
+      unless ancestors.include?(mod)
+        node[:dependencies] ||= []
+        missing_deps = mod.unmet_dependencies.select do |dep|
+          dep[:reason] == :missing
+        end
+        missing_deps.map do |mis_mod|
+          str = "#{colorize(:bg_red, 'UNMET DEPENDENCY')} #{mis_mod[:name].gsub('/', '-')} "
+          str << "(#{colorize(:cyan, mis_mod[:version_constraint])})"
+          node[:dependencies] << { :text => str }
+        end
+        node[:dependencies] += list_build_tree(mod.dependencies_as_modules,
+          ancestors + [mod], mod, params)
+      end
+
+      node
+    end.compact
+  end
+
+  # Prepare a module object for print in a tree view.  Each node in the tree
+  # must be a Hash in the following format:
+  #
+  #    { :text => "puppetlabs-mysql (v1.0.0)" }
+  #
+  # The value of a module's :text is affected by three (3) factors: the format
+  # of the tree, it's dependency status, and the location in the modulepath
+  # relative to it's parent.
+  #
+  # Returns a Hash
+  #
+  def list_build_node(mod, parent, params)
+    str = ''
+    str << (mod.forge_name ? mod.forge_name.gsub('/', '-') : mod.name)
+    str << ' (' + colorize(:cyan, mod.version ? "v#{mod.version}" : '???') + ')'
+
+    unless File.dirname(mod.path) == params[:path]
+      str << " [#{File.dirname(mod.path)}]"
+    end
+
+    if @unmet_deps[:version_mismatch].include?(mod.forge_name)
+      if params[:label_invalid]
+        str << '  ' + colorize(:red, 'invalid')
+      elsif parent.respond_to?(:forge_name)
+        unmet_parent = @unmet_deps[:version_mismatch][mod.forge_name][:parent]
+        if (unmet_parent[:name] == parent.forge_name &&
+            unmet_parent[:version] == "v#{parent.version}")
+          str << '  ' + colorize(:red, 'invalid')
+        end
+      end
+    end
 
+    { :text => str }
   end
 end