puppet-retrospec 0.12.2 → 1.0.0

data/vendor/gems/puppet-4.5.2/lib/puppet/application/epp.rb

@@ -0,0 +1,5 @@
+require 'puppet/application/face_base'
+require 'puppet/face'
+
+class Puppet::Application::Epp < Puppet::Application::FaceBase
+end

data/vendor/gems/puppet-4.5.2/lib/puppet/application/face_base.rb

@@ -0,0 +1,269 @@
+require 'puppet/application'
+require 'puppet/face'
+require 'optparse'
+require 'pp'
+
+class Puppet::Application::FaceBase < Puppet::Application
+  option("--debug", "-d") do |arg|
+    set_log_level(:debug => true)
+  end
+
+  option("--verbose", "-v") do |_|
+    set_log_level(:verbose => true)
+  end
+
+  option("--render-as FORMAT") do |format|
+    self.render_as = format.to_sym
+  end
+
+  option("--help", "-h") do |arg|
+    if action && !@is_default_action
+      # Only invoke help on the action if it was specified, not if
+      # it was the default action.
+      puts Puppet::Face[:help, :current].help(face.name, action.name)
+    else
+      puts Puppet::Face[:help, :current].help(face.name)
+    end
+    exit
+  end
+
+  attr_accessor :face, :action, :type, :arguments, :render_as
+
+  def render_as=(format)
+    if format == :json then
+      @render_as = Puppet::Network::FormatHandler.format(:pson)
+    else
+      @render_as = Puppet::Network::FormatHandler.format(format)
+    end
+    @render_as or raise ArgumentError, "I don't know how to render '#{format}'"
+  end
+
+  def render(result, args_and_options)
+    hook = action.when_rendering(render_as.name)
+
+    if hook
+      # when defining when_rendering on your action you can optionally
+      # include arguments and options
+      if hook.arity > 1
+        result = hook.call(result, *args_and_options)
+      else
+        result = hook.call(result)
+      end
+    end
+
+    render_as.render(result)
+  end
+
+  def preinit
+    super
+    Signal.trap(:INT) do
+      $stderr.puts "Cancelling Face"
+      exit(0)
+    end
+  end
+
+  def parse_options
+    # We need to parse enough of the command line out early, to identify what
+    # the action is, so that we can obtain the full set of options to parse.
+
+    # REVISIT: These should be configurable versions, through a global
+    # '--version' option, but we don't implement that yet... --daniel 2011-03-29
+    @type = Puppet::Util::ConstantInflector.constant2file(self.class.name.to_s.sub(/.+:/, '')).to_sym
+    @face = Puppet::Face[@type, :current]
+
+    # Now, walk the command line and identify the action.  We skip over
+    # arguments based on introspecting the action and all, and find the first
+    # non-option word to use as the action.
+    action_name = nil
+    index       = -1
+    until action_name or (index += 1) >= command_line.args.length do
+      item = command_line.args[index]
+      if item =~ /^-/ then
+        option = @face.options.find do |name|
+          item =~ /^-+#{name.to_s.gsub(/[-_]/, '[-_]')}(?:[ =].*)?$/
+        end
+        if option then
+          option = @face.get_option(option)
+          # If we have an inline argument, just carry on.  We don't need to
+          # care about optional vs mandatory in that case because we do a real
+          # parse later, and that will totally take care of raising the error
+          # when we get there. --daniel 2011-04-04
+          if option.takes_argument? and !item.index('=') then
+            index += 1 unless
+              (option.optional_argument? and command_line.args[index + 1] =~ /^-/)
+          end
+        elsif option = find_global_settings_argument(item) then
+          unless Puppet.settings.boolean? option.name then
+            # As far as I can tell, we treat non-bool options as always having
+            # a mandatory argument. --daniel 2011-04-05
+            # ... But, the mandatory argument will not be the next item if an = is
+            # employed in the long form of the option. --jeffmccune 2012-09-18
+            index += 1 unless item =~ /^--#{option.name}=/
+          end
+        elsif option = find_application_argument(item) then
+          index += 1 if (option[:argument] and not option[:optional])
+        else
+          raise OptionParser::InvalidOption.new(item.sub(/=.*$/, ''))
+        end
+      else
+        # Stash away the requested action name for later, and try to fetch the
+        # action object it represents; if this is an invalid action name that
+        # will be nil, and handled later.
+        action_name = item.to_sym
+        @action = Puppet::Face.find_action(@face.name, action_name)
+        @face   = @action.face if @action
+      end
+    end
+
+    if @action.nil?
+      if @action = @face.get_default_action() then
+        @is_default_action = true
+      else
+        # First try to handle global command line options
+        # But ignoring invalid options as this is a invalid action, and
+        # we want the error message for that instead.
+        begin
+          super
+        rescue OptionParser::InvalidOption
+        end
+
+        face   = @face.name
+        action = action_name.nil? ? 'default' : "'#{action_name}'"
+        msg = "'#{face}' has no #{action} action.  See `puppet help #{face}`."
+
+        Puppet.err(msg)
+        Puppet::Util::Log.force_flushqueue()
+
+        exit false
+      end
+    end
+
+    # Now we can interact with the default option code to build behaviour
+    # around the full set of options we now know we support.
+    @action.options.each do |o|
+      o = @action.get_option(o) # make it the object.
+      self.class.option(*o.optparse) # ...and make the CLI parse it.
+    end
+
+    # ...and invoke our parent to parse all the command line options.
+    super
+  end
+
+  def find_global_settings_argument(item)
+    Puppet.settings.each do |name, object|
+      object.optparse_args.each do |arg|
+        next unless arg =~ /^-/
+        # sadly, we have to emulate some of optparse here...
+        pattern = /^#{arg.sub('[no-]', '').sub(/[ =].*$/, '')}(?:[ =].*)?$/
+        pattern.match item and return object
+      end
+    end
+    return nil                  # nothing found.
+  end
+
+  def find_application_argument(item)
+    self.class.option_parser_commands.each do |options, function|
+      options.each do |option|
+        next unless option =~ /^-/
+        pattern = /^#{option.sub('[no-]', '').sub(/[ =].*$/, '')}(?:[ =].*)?$/
+        next unless pattern.match(item)
+        return {
+          :argument => option =~ /[ =]/,
+          :optional => option =~ /[ =]\[/
+        }
+      end
+    end
+    return nil                  # not found
+  end
+
+  def setup
+    Puppet::Util::Log.newdestination :console
+
+    @arguments = command_line.args
+
+    # Note: because of our definition of where the action is set, we end up
+    # with it *always* being the first word of the remaining set of command
+    # line arguments.  So, strip that off when we construct the arguments to
+    # pass down to the face action. --daniel 2011-04-04
+    # Of course, now that we have default actions, we should leave the
+    # "action" name on if we didn't actually consume it when we found our
+    # action.
+    @arguments.delete_at(0) unless @is_default_action
+
+    # We copy all of the app options to the end of the call; This allows each
+    # action to read in the options.  This replaces the older model where we
+    # would invoke the action with options set as global state in the
+    # interface object.  --daniel 2011-03-28
+    @arguments << options
+
+    # If we don't have a rendering format, set one early.
+    self.render_as ||= (@action.render_as || :console)
+  end
+
+
+  def main
+    status = false
+
+    # Call the method associated with the provided action (e.g., 'find').
+    unless @action
+      puts Puppet::Face[:help, :current].help(@face.name)
+      raise "#{face} does not respond to action #{arguments.first}"
+    end
+
+    # We need to do arity checking here because this is generic code
+    # calling generic methods – that have argument defaulting.  We need to
+    # make sure we don't accidentally pass the options as the first
+    # argument to a method that takes one argument.  eg:
+    #
+    #   puppet facts find
+    #   => options => {}
+    #      @arguments => [{}]
+    #   => @face.send :bar, {}
+    #
+    #   def face.bar(argument, options = {})
+    #   => bar({}, {})  # oops!  we thought the options were the
+    #                   # positional argument!!
+    #
+    # We could also fix this by making it mandatory to pass the options on
+    # every call, but that would make the Ruby API much more annoying to
+    # work with; having the defaulting is a much nicer convention to have.
+    #
+    # We could also pass the arguments implicitly, by having a magic
+    # 'options' method that was visible in the scope of the action, which
+    # returned the right stuff.
+    #
+    # That sounds attractive, but adds complications to all sorts of
+    # things, especially when you think about how to pass options when you
+    # are writing Ruby code that calls multiple faces.  Especially if
+    # faces are involved in that. ;)
+    #
+    # --daniel 2011-04-27
+    if (arity = @action.positional_arg_count) > 0
+      unless (count = arguments.length) == arity then
+        s = arity == 2 ? '' : 's'
+        raise ArgumentError, "puppet #{@face.name} #{@action.name} takes #{arity-1} argument#{s}, but you gave #{count-1}"
+      end
+    end
+
+    result = @face.send(@action.name, *arguments)
+    puts render(result, arguments) unless result.nil?
+    status = true
+
+  # We need an easy way for the action to set a specific exit code, so we
+  # rescue SystemExit here; This allows each action to set the desired exit
+  # code by simply calling Kernel::exit.  eg:
+  #
+  #   exit(2)
+  #
+  # --kelsey 2012-02-14
+  rescue SystemExit => detail
+    status = detail.status
+
+  rescue => detail
+    Puppet.log_exception(detail)
+    Puppet.err "Try 'puppet help #{@face.name} #{@action.name}' for usage"
+
+  ensure
+    exit status
+  end
+end

data/vendor/gems/puppet-4.5.2/lib/puppet/application/filebucket.rb

@@ -0,0 +1,258 @@
+require 'puppet/application'
+
+class Puppet::Application::Filebucket < Puppet::Application
+
+  option("--bucket BUCKET","-b")
+  option("--debug","-d")
+  option("--fromdate FROMDATE","-f")
+  option("--todate TODATE","-t")
+  option("--local","-l")
+  option("--remote","-r")
+  option("--verbose","-v")
+
+  attr :args
+
+  def help
+    <<-'HELP'
+
+puppet-filebucket(8) -- Store and retrieve files in a filebucket
+========
+
+SYNOPSIS
+--------
+A stand-alone Puppet filebucket client.
+
+
+USAGE
+-----
+puppet filebucket <mode> [-h|--help] [-V|--version] [-d|--debug]
+  [-v|--verbose] [-l|--local] [-r|--remote] [-s|--server <server>]
+  [-f|--fromdate <date>] [-t|--todate <date>] [-b|--bucket <directory>]
+  <file> <file> ...
+
+Puppet filebucket can operate in three modes, with only one mode per call:
+
+backup:
+  Send one or more files to the specified file bucket. Each sent file is
+  printed with its resulting md5 sum.
+
+get:
+  Return the text associated with an md5 sum. The text is printed to
+  stdout, and only one file can be retrieved at a time.
+
+restore:
+  Given a file path and an md5 sum, store the content associated with
+  the sum into the specified file path. You can specify an entirely new
+  path to this argument; you are not restricted to restoring the content
+  to its original location.
+
+diff:
+  Print a diff in unified format between two checksums in the filebucket
+  or between a checksum and its matching file.
+
+list:
+  List all files in the current local filebucket. Listing remote
+  filebuckets is not allowed.
+
+DESCRIPTION
+-----------
+This is a stand-alone filebucket client for sending files to a local or
+central filebucket.
+
+Note that 'filebucket' defaults to using a network-based filebucket
+available on the server named 'puppet'. To use this, you'll have to be
+running as a user with valid Puppet certificates. Alternatively, you can
+use your local file bucket by specifying '--local'.
+
+
+OPTIONS
+-------
+Note that any setting that's valid in the configuration
+file is also a valid long argument. For example, 'ssldir' is a valid
+setting, so you can specify '--ssldir <directory>' as an
+argument.
+
+See the configuration file documentation at
+https://docs.puppetlabs.com/puppet/latest/reference/configuration.html for the
+full list of acceptable parameters. A commented list of all
+configuration options can also be generated by running puppet with
+'--genconfig'.
+
+* --debug:
+  Enable full debugging.
+
+* --fromdate:
+  (list only) Select bucket files from 'fromdate'
+
+* --help:
+  Print this help message
+
+* --local:
+  Use the local filebucket. This will use the default configuration
+  information.
+
+* --remote:
+  Use a remote filebucket. This will use the default configuration
+  information.
+
+* --server:
+  The server to send the file to, instead of locally.
+
+* --todate:
+  (list only) Select bucket files until 'todate'
+
+* --verbose:
+  Print extra information.
+
+* --version:
+  Print version information.
+
+
+EXAMPLE
+-------
+    $ puppet filebucket backup /etc/passwd
+    /etc/passwd: 429b225650b912a2ee067b0a4cf1e949
+    $ puppet filebucket restore /tmp/passwd 429b225650b912a2ee067b0a4cf1e949
+    ## Diff between two files in the filebucket
+    $ puppet filebucket -l diff d43a6ecaa892a1962398ac9170ea9bf2 7ae322f5791217e031dc60188f4521ef
+    1a2
+    > again
+    ## Diff between the file in the filebucket and the current one
+    $ puppet filebucket -l diff d43a6ecaa892a1962398ac9170ea9bf2 /tmp/testFile
+    1a2
+    > again
+    $ puppet filebucket -l list
+    d43a6ecaa892a1962398ac9170ea9bf2 2015-05-11 09:27:56 /tmp/TestFile
+    $ echo again >> /tmp/TestFile
+    $ puppet filebucket -l backup /tmp/TestFile
+    /tmp/TestFile: 7ae322f5791217e031dc60188f4521ef
+    $ puppet filebucket -l  list
+    d43a6ecaa892a1962398ac9170ea9bf2 2015-05-11 09:27:56 /tmp/TestFile
+    7ae322f5791217e031dc60188f4521ef 2015-05-11 09:52:15 /tmp/TestFile
+    $ puppet filebucket -l -f 2015-01-01 -t 2015-01-11 list
+    <Empty Output>
+    $ puppet filebucket -l -f 2015-05-10 list
+    d43a6ecaa892a1962398ac9170ea9bf2 2015-05-11 09:27:56 /tmp/TestFile
+    7ae322f5791217e031dc60188f4521ef 2015-05-11 09:52:15 /tmp/TestFile
+    $ puppet filebucket -l -f "2015-05-11 09:30:00" list
+    7ae322f5791217e031dc60188f4521ef 2015-05-11 09:52:15 /tmp/TestFile
+    $ puppet filebucket -l -t "2015-05-11 09:30:00" list
+    d43a6ecaa892a1962398ac9170ea9bf2 2015-05-11 09:27:56 /tmp/TestFile
+
+AUTHOR
+------
+Luke Kanies
+
+
+COPYRIGHT
+---------
+Copyright (c) 2011 Puppet Labs, LLC Licensed under the Apache 2.0 License
+
+    HELP
+  end
+
+
+  def run_command
+    @args = command_line.args
+    command = args.shift
+    return send(command) if %w{get backup restore diff list}.include? command
+    help
+  end
+
+  def get
+    md5 = args.shift
+    out = @client.getfile(md5)
+    print out
+  end
+
+  def backup
+    raise "You must specify a file to back up" unless args.length > 0
+
+    args.each do |file|
+      unless Puppet::FileSystem.exist?(file)
+        $stderr.puts "#{file}: no such file"
+        next
+      end
+      unless FileTest.readable?(file)
+        $stderr.puts "#{file}: cannot read file"
+        next
+      end
+      md5 = @client.backup(file)
+      puts "#{file}: #{md5}"
+    end
+  end
+
+  def list
+    fromdate = options[:fromdate]
+    todate = options[:todate]
+    out = @client.list(fromdate, todate)
+    print out
+  end
+
+  def restore
+    file = args.shift
+    md5 = args.shift
+    @client.restore(file, md5)
+  end
+
+  def diff
+    raise Puppet::Error, "Need exactly two arguments: filebucket diff <file_a> <file_b>" unless args.count == 2
+    left = args.shift
+    right = args.shift
+    if Puppet::FileSystem.exist?(left)
+      # It's a file
+      file_a = left
+      checksum_a = nil
+    else
+      file_a = nil
+      checksum_a = left
+    end
+    if Puppet::FileSystem.exist?(right)
+      # It's a file
+      file_b = right
+      checksum_b = nil
+    else
+      file_b = nil
+      checksum_b = right
+    end
+    if (checksum_a || file_a) && (checksum_b || file_b)
+      Puppet.info("Comparing #{checksum_a} #{checksum_b} #{file_a} #{file_b}")
+      print @client.diff(checksum_a, checksum_b, file_a, file_b)
+    else
+      raise Puppet::Error, "Need exactly two arguments: filebucket diff <file_a> <file_b>"
+    end
+  end
+
+  def setup
+    Puppet::Log.newdestination(:console)
+
+    @client = nil
+    @server = nil
+
+    Signal.trap(:INT) do
+      $stderr.puts "Cancelling"
+      exit(1)
+    end
+
+    if options[:debug]
+      Puppet::Log.level = :debug
+    elsif options[:verbose]
+      Puppet::Log.level = :info
+    end
+
+      exit(Puppet.settings.print_configs ? 0 : 1) if Puppet.settings.print_configs?
+
+    require 'puppet/file_bucket/dipper'
+    begin
+      if options[:local] or options[:bucket]
+        path = options[:bucket] || Puppet[:bucketdir]
+        @client = Puppet::FileBucket::Dipper.new(:Path => path)
+      else
+        @client = Puppet::FileBucket::Dipper.new(:Server => Puppet[:server])
+      end
+    rescue => detail
+      Puppet.log_exception(detail)
+      exit(1)
+    end
+  end
+end