openvox 7.37.1

data/lib/puppet/util/command_line.rb

@@ -0,0 +1,196 @@
+# Bundler and rubygems maintain a set of directories from which to
+# load gems. If Bundler is loaded, let it determine what can be
+# loaded. If it's not loaded, then use rubygems. But do this before
+# loading any puppet code, so that our gem loading system is sane.
+if not defined? ::Bundler
+  begin
+    require 'rubygems'
+  rescue LoadError
+  end
+end
+
+require_relative '../../puppet'
+require_relative '../../puppet/util'
+require_relative '../../puppet/util/rubygems'
+require_relative '../../puppet/util/limits'
+require_relative '../../puppet/util/colors'
+require_relative '../../puppet/gettext/module_translations'
+
+module Puppet
+  module Util
+    # This is the main entry point for all puppet applications / faces; it
+    # is basically where the bootstrapping process / lifecycle of an app
+    # begins.
+    class CommandLine
+      include Puppet::Util::Limits
+
+      OPTION_OR_MANIFEST_FILE = /^-|\.pp$/
+
+      # @param zero [String] the name of the executable
+      # @param argv [Array<String>] the arguments passed on the command line
+      # @param stdin [IO] (unused)
+      def initialize(zero = $0, argv = ARGV, stdin = STDIN)
+        @command = File.basename(zero, '.rb')
+        @argv = argv
+      end
+
+      # @return [String] name of the subcommand is being executed
+      # @api public
+      def subcommand_name
+        return @command if @command != 'puppet'
+
+        if @argv.first =~ OPTION_OR_MANIFEST_FILE
+          nil
+        else
+          @argv.first
+        end
+      end
+
+      # @return [Array<String>] the command line arguments being passed to the subcommand
+      # @api public
+      def args
+        return @argv if @command != 'puppet'
+
+        if subcommand_name.nil?
+          @argv
+        else
+          @argv[1..-1]
+        end
+      end
+
+      # Run the puppet subcommand. If the subcommand is determined to be an
+      # external executable, this method will never return and the current
+      # process will be replaced via {Kernel#exec}.
+      #
+      # @return [void]
+      def execute
+        require_config = true
+        if @argv.first =~ /help|-h|--help|-V|--version/
+          require_config = false
+        end
+        Puppet::Util.exit_on_fail(_("Could not initialize global default settings")) do
+          Puppet.initialize_settings(args, require_config)
+        end
+
+        setpriority(Puppet[:priority])
+
+        find_subcommand.run
+      end
+
+      # @api private
+      def external_subcommand
+        Puppet::Util.which("puppet-#{subcommand_name}")
+      end
+
+      private
+
+      def find_subcommand
+        if subcommand_name.nil?
+          if args.include?("--help") || args.include?("-h")
+            ApplicationSubcommand.new("help", CommandLine.new("puppet", ["help"]))
+          else
+            NilSubcommand.new(self)
+          end
+        elsif Puppet::Application.available_application_names.include?(subcommand_name)
+          ApplicationSubcommand.new(subcommand_name, self)
+        else
+          path_to_subcommand = external_subcommand
+          if path_to_subcommand
+            ExternalSubcommand.new(path_to_subcommand, self)
+          else
+            UnknownSubcommand.new(subcommand_name, self)
+          end
+        end
+      end
+
+      # @api private
+      class ApplicationSubcommand
+        def initialize(subcommand_name, command_line)
+          @subcommand_name = subcommand_name
+          @command_line = command_line
+        end
+
+        def run
+          # For most applications, we want to be able to load code from the modulepath,
+          # such as apply, describe, resource, and faces.
+          # For agent and device in agent mode, we only want to load pluginsync'ed code from libdir.
+          # For master, we shouldn't ever be loading per-environment code into the master's
+          # ruby process, but that requires fixing (#17210, #12173, #8750). So for now
+          # we try to restrict to only code that can be autoloaded from the node's
+          # environment.
+
+          # PUP-2114 - at this point in the bootstrapping process we do not
+          # have an appropriate application-wide current_environment set.
+          # If we cannot find the configured environment, which may not exist,
+          # we do not attempt to add plugin directories to the load path.
+          unless @subcommand_name == 'master' || @subcommand_name == 'agent' || (@subcommand_name == 'device' && (['--apply', '--facts', '--resource'] - @command_line.args).empty?)
+            configured_environment = Puppet.lookup(:environments).get(Puppet[:environment])
+            if configured_environment
+              configured_environment.each_plugin_directory do |dir|
+                $LOAD_PATH << dir unless $LOAD_PATH.include?(dir)
+              end
+
+              Puppet::ModuleTranslations.load_from_modulepath(configured_environment.modules)
+              Puppet::ModuleTranslations.load_from_vardir(Puppet[:vardir])
+
+              # Puppet requires Facter, which initializes its lookup paths. Reset Facter to
+              # pickup the new $LOAD_PATH.
+              Puppet.runtime[:facter].reset
+            end
+          end
+
+          app = Puppet::Application.find(@subcommand_name).new(@command_line)
+          app.run
+        end
+      end
+
+      # @api private
+      class ExternalSubcommand
+        def initialize(path_to_subcommand, command_line)
+          @path_to_subcommand = path_to_subcommand
+          @command_line = command_line
+        end
+
+        def run
+          Kernel.exec(@path_to_subcommand, *@command_line.args)
+        end
+      end
+
+      # @api private
+      class NilSubcommand
+        include Puppet::Util::Colors
+
+        def initialize(command_line)
+          @command_line = command_line
+        end
+
+        def run
+          args = @command_line.args
+          if args.include? "--version" or args.include? "-V"
+            puts Puppet.version
+          elsif @command_line.subcommand_name.nil? && args.count > 0
+            # If the subcommand is truly nil and there is an arg, it's an option; print out the invalid option message
+            puts colorize(:hred, _("Error: Could not parse application options: invalid option: %{opt}") % { opt: args[0] })
+            exit 1
+          else
+            puts _("See 'puppet help' for help on available puppet subcommands")
+          end
+        end
+      end
+
+      # @api private
+      class UnknownSubcommand < NilSubcommand
+        def initialize(subcommand_name, command_line)
+          @subcommand_name = subcommand_name
+          super(command_line)
+        end
+
+        def run
+          puts colorize(:hred, _("Error: Unknown Puppet subcommand '%{cmd}'") % { cmd: @subcommand_name })
+          super
+          exit 1
+        end
+      end
+    end
+  end
+end

data/lib/puppet/util/constant_inflector.rb

@@ -0,0 +1,24 @@
+# Created on 2008-02-12
+# Copyright Luke Kanies
+
+# NOTE: I think it might be worth considering moving these methods directly into Puppet::Util.
+
+# A common module for converting between constants and
+# file names.
+
+
+module Puppet
+  module Util
+    module ConstantInflector
+      def file2constant(file)
+        file.split("/").collect { |name| name.capitalize }.join("::").gsub(/_+(.)/) { |term| $1.capitalize }
+      end
+      module_function :file2constant
+
+      def constant2file(constant)
+        constant.to_s.gsub(/([a-z])([A-Z])/) { |term| $1 + "_#{$2}" }.gsub("::", "/").downcase
+      end
+      module_function :constant2file
+    end
+  end
+end

data/lib/puppet/util/diff.rb

@@ -0,0 +1,81 @@
+require 'tempfile'
+
+# Provide a diff between two strings.
+module Puppet::Util::Diff
+  include Puppet::Util::Execution
+  require 'tempfile'
+
+  def diff(old, new)
+    diff_cmd = Puppet[:diff]
+    return '' unless diff_cmd && diff_cmd != ""
+
+    command = [diff_cmd]
+    args = Puppet[:diff_args]
+    if args && args != ""
+      args.split(' ').each do|arg|
+        command << arg
+      end
+    end
+    command << old << new
+    Puppet::Util::Execution.execute(command, :failonfail => false, :combine => false)
+  end
+
+  module_function :diff
+
+  # return diff string of two input strings
+  # format defaults to unified
+  # context defaults to 3 lines
+  def lcs_diff(data_old, data_new, format=:unified, context_lines=3)
+    unless Puppet.features.diff?
+      Puppet.warning _("Cannot provide diff without the diff/lcs Ruby library")
+      return ""
+    end
+    data_old = data_old.split(/\n/).map! { |e| e.chomp }
+    data_new = data_new.split(/\n/).map! { |e| e.chomp }
+
+    output = ""
+
+    diffs = ::Diff::LCS.diff(data_old, data_new)
+    return output if diffs.empty?
+
+    oldhunk = hunk = nil
+    file_length_difference = 0
+
+    diffs.each do |piece|
+      begin
+
+        hunk = ::Diff::LCS::Hunk.new(
+          data_old, data_new, piece,
+            context_lines,
+
+            file_length_difference)
+        file_length_difference = hunk.file_length_difference
+      next unless oldhunk
+      # Hunks may overlap, which is why we need to be careful when our
+      # diff includes lines of context. Otherwise, we might print
+      # redundant lines.
+      if (context_lines > 0) and hunk.overlaps?(oldhunk)
+        hunk.unshift(oldhunk)
+      else
+        output << oldhunk.diff(format)
+      end
+      ensure
+        oldhunk = hunk
+        output << "\n"
+      end
+    end
+
+    # Handle the last remaining hunk
+    output << oldhunk.diff(format) << "\n"
+  end
+
+  def string_file_diff(path, string)
+    tempfile = Tempfile.new("puppet-diffing")
+    tempfile.open
+    tempfile.print string
+    tempfile.close
+    notice "\n" + diff(path, tempfile.path)
+    tempfile.delete
+  end
+end
+

data/lib/puppet/util/docs.rb

@@ -0,0 +1,128 @@
+# Some simple methods for helping manage automatic documentation generation.
+module Puppet::Util::Docs
+  # Specify the actual doc string.
+  def desc(str)
+    @doc = str
+  end
+
+  # Add a new autodoc block.  We have to define these as class methods,
+  # rather than just sticking them in a hash, because otherwise they're
+  # too difficult to do inheritance with.
+  def dochook(name, &block)
+    method = "dochook_#{name}"
+
+    meta_def method, &block
+  end
+
+  attr_writer :doc
+
+  # Generate the full doc string.
+  def doc
+    extra = methods.find_all { |m| m.to_s =~ /^dochook_.+/ }.sort.collect { |m|
+      self.send(m)
+    }.delete_if {|r| r.nil? }.collect {|r| "* #{r}"}.join("\n")
+
+    if @doc
+      scrub(@doc) + (extra.empty? ? '' : "\n\n#{extra}")
+    else
+      extra
+    end
+  end
+
+  # Build a table
+  def doctable(headers, data)
+    str = "\n\n"
+
+    lengths = []
+    # Figure out the longest field for all columns
+    data.each do |name, values|
+      [name, values].flatten.each_with_index do |value, i|
+        lengths[i] ||= 0
+        lengths[i] = value.to_s.length if value.to_s.length > lengths[i]
+      end
+    end
+
+    # The headers could also be longest
+    headers.each_with_index do |value, i|
+      lengths[i] = value.to_s.length if value.to_s.length > lengths[i]
+    end
+
+    # Add the header names
+    str += headers.zip(lengths).collect { |value, num| pad(value, num) }.join(" | ") + " |" + "\n"
+
+    # And the header row
+    str += lengths.collect { |num| "-" * num }.join(" | ") + " |" + "\n"
+
+    # Now each data row
+    data.sort { |a, b| a[0].to_s <=> b[0].to_s }.each do |name, rows|
+      str += [name, rows].flatten.zip(lengths).collect do |value, length|
+        pad(value, length)
+      end.join(" | ") + " |" + "\n"
+    end
+
+    str + "\n"
+  end
+
+  # There is nothing that would ever set this. It gets read in reference/type.rb, but will never have any value but nil.
+  attr_reader :nodoc
+  def nodoc?
+    nodoc
+  end
+
+  # Pad a field with spaces
+  def pad(value, length)
+    value.to_s + (" " * (length - value.to_s.length))
+  end
+
+  HEADER_LEVELS = [nil, "#", "##", "###", "####", "#####"]
+
+  def markdown_header(name, level)
+    "#{HEADER_LEVELS[level]} #{name}\n\n"
+  end
+
+  def markdown_definitionlist(term, definition)
+    lines = scrub(definition).split("\n")
+    str = "#{term}\n: #{lines.shift}\n"
+    lines.each do |line|
+      str << "  " if line =~ /\S/
+      str << "#{line}\n"
+    end
+    str << "\n"
+  end
+
+  # Strip indentation and trailing whitespace from embedded doc fragments.
+  #
+  # Multi-line doc fragments are sometimes indented in order to preserve the
+  # formatting of the code they're embedded in. Since indents are syntactic
+  # elements in Markdown, we need to make sure we remove any indent that was
+  # added solely to preserve surrounding code formatting, but LEAVE any indent
+  # that delineates a Markdown element (code blocks, multi-line bulleted list
+  # items). We can do this by removing the *least common indent* from each line.
+  #
+  # Least common indent is defined as follows:
+  #
+  # * Find the smallest amount of leading space on any line...
+  # * ...excluding the first line (which may have zero indent without affecting
+  #   the common indent)...
+  # * ...and excluding lines that consist solely of whitespace.
+  # * The least common indent may be a zero-length string, if the fragment is
+  #   not indented to match code.
+  # * If there are hard tabs for some dumb reason, we assume they're at least
+  #   consistent within this doc fragment.
+  #
+  # See tests in spec/unit/util/docs_spec.rb for examples.
+  def scrub(text)
+    # One-liners are easy! (One-liners may be buffered with extra newlines.)
+    return text.strip if text.strip !~ /\n/
+    excluding_first_line = text.partition("\n").last
+    indent = excluding_first_line.scan(/^[ \t]*(?=\S)/).min || '' # prevent nil
+    # Clean hanging indent, if any
+    if indent.length > 0
+      text = text.gsub(/^#{indent}/, '')
+    end
+    # Clean trailing space
+    text.lines.map{|line|line.rstrip}.join("\n").rstrip
+  end
+
+  module_function :scrub
+end

data/lib/puppet/util/errors.rb

@@ -0,0 +1,159 @@
+# Some helper methods for throwing and populating errors.
+#
+# @api public
+module Puppet::Util::Errors
+  # Throw a Puppet::DevError with the specified message.  Used for unknown or
+  # internal application failures.
+  #
+  # @param msg [String] message used in raised error
+  # @raise [Puppet::DevError] always raised with the supplied message
+  def devfail(msg)
+    self.fail(Puppet::DevError, msg)
+  end
+
+  # Add line and file info to the supplied exception if info is available from
+  # this object, is appropriately populated and the supplied exception supports
+  # it.  When other is supplied, the backtrace will be copied to the error
+  # object and the 'original' will be dropped from the error.
+  #
+  # @param error [Exception] exception that is populated with info
+  # @param other [Exception] original exception, source of backtrace info
+  # @return [Exception] error parameter
+  def adderrorcontext(error, other = nil)
+    error.line ||= self.line if error.respond_to?(:line=) and self.respond_to?(:line) and self.line
+    error.file ||= self.file if error.respond_to?(:file=) and self.respond_to?(:file) and self.file
+    error.original ||= other if error.respond_to?(:original=)
+
+    error.set_backtrace(other.backtrace) if other and other.respond_to?(:backtrace)
+    # It is not meaningful to keep the wrapped exception since its backtrace has already
+    # been adopted by the error. (The instance variable is private for good reasons).
+    error.instance_variable_set(:@original, nil)
+    error
+  end
+
+  # Return a human-readable string of this object's file, line, and pos attributes,
+  # if set.
+  #
+  # @param file [String] the file path for the error (nil or "", for not known)
+  # @param line [String] the line number for the error (nil or "", for not known)
+  # @param column [String] the column number for the error (nil or "",  for not known)
+  # @return [String] description of file, line, and column
+  #
+  def self.error_location(file, line=nil, column=nil)
+    file = nil if (file.is_a?(String) && file.empty?)
+    line = nil if (line.is_a?(String) && line.empty?)
+    column = nil if (column.is_a?(String) && column.empty?)
+    if file and line and column
+      _("(file: %{file}, line: %{line}, column: %{column})") % { file: file, line: line, column: column }
+    elsif file and line
+      _("(file: %{file}, line: %{line})") % { file: file, line: line }
+    elsif line and column
+      _("(line: %{line}, column: %{column})") % { line: line, column: column }
+    elsif line
+      _("(line: %{line})") % { line: line }
+    elsif file
+      _("(file: %{file})") % { file: file }
+    else
+      ''
+    end
+  end
+
+  # Return a human-readable string of this object's file, line, and pos attributes,
+  # with a proceeding space in the output
+  # if set.
+  #
+  # @param file [String] the file path for the error (nil or "", for not known)
+  # @param line [String] the line number for the error (nil or "", for not known)
+  # @param column [String] the column number for the error (nil or "",  for not known)
+  # @return [String] description of file, line, and column
+  #
+  def self.error_location_with_space(file, line=nil, column=nil)
+    error_location_str = error_location(file, line, column)
+    if error_location_str.empty?
+      ''
+    else
+      ' ' + error_location_str
+    end
+  end
+
+  # Return a human-readable string of this object's file and line
+  # where unknown entries are listed as 'unknown'
+  #
+  # @param file [String] the file path for the error (nil or "", for not known)
+  # @param line [String] the line number for the error (nil or "", for not known)
+  # @return [String] description of file, and line
+  def self.error_location_with_unknowns(file, line)
+    file = nil if (file.is_a?(String) && file.empty?)
+    line = nil if (line.is_a?(String) && line.empty?)
+    file = _('unknown') unless file
+    line = _('unknown') unless line
+    error_location(file, line)
+  end
+
+  # Return a human-readable string of this object's file and line attributes,
+  # if set.
+  #
+  # @return [String] description of file and line with a leading space
+  def error_context
+    Puppet::Util::Errors.error_location_with_space(file, line)
+  end
+
+  # Wrap a call in such a way that we always throw the right exception and keep
+  # as much context as possible.
+  #
+  # @param options [Hash<Symbol,Object>] options used to create error
+  # @option options [Class] :type error type to raise, defaults to
+  #   Puppet::DevError
+  # @option options [String] :message message to use in error, default mentions
+  #   the name of this class
+  # @raise [Puppet::Error] re-raised with extra context if the block raises it
+  # @raise [Error] of type options[:type], when the block raises other
+  #   exceptions
+  def exceptwrap(options = {})
+    options[:type] ||= Puppet::DevError
+    begin
+      return yield
+    rescue Puppet::Error => detail
+      raise adderrorcontext(detail)
+    rescue => detail
+      message = options[:message] || _("%{klass} failed with error %{error_type}: %{detail}") % { klass: self.class, error_type: detail.class, detail: detail }
+
+      error = options[:type].new(message)
+      # We can't use self.fail here because it always expects strings,
+      # not exceptions.
+      raise adderrorcontext(error, detail)
+    end
+
+    retval
+  end
+
+  # Throw an error, defaulting to a Puppet::Error.
+  #
+  # @overload fail(message, ..)
+  #   Throw a Puppet::Error with a message concatenated from the given
+  #   arguments.
+  #   @param [String] message error message(s)
+  # @overload fail(error_klass, message, ..)
+  #   Throw an exception of type error_klass with a message concatenated from
+  #   the given arguments.
+  #   @param [Class] type of error
+  #   @param [String] message error message(s)
+  # @overload fail(error_klass, message, ..)
+  #   Throw an exception of type error_klass with a message concatenated from
+  #   the given arguments.
+  #   @param [Class] type of error
+  #   @param [String] message error message(s)
+  #   @param [Exception] original exception, source of backtrace info
+  def fail(*args)
+    if args[0].is_a?(Class)
+      type = args.shift
+    else
+      type = Puppet::Error
+    end
+
+    other = args.count > 1 ? args.pop : nil
+    error = adderrorcontext(type.new(args.join(" ")), other)
+
+    raise error
+  end
+end