openvox 7.37.1

data/lib/puppet/application/face_base.rb

@@ -0,0 +1,276 @@
+require_relative '../../puppet/application'
+require_relative '../../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(0)
+  end
+
+  attr_reader :render_as
+  attr_accessor :face, :action, :type, :arguments
+
+  def render_as=(format)
+    @render_as = Puppet::Network::FormatHandler.format(format)
+    @render_as or raise ArgumentError, _("I don't know how to render '%{format}'") % { format: 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 =~ /^-/
+        option = @face.options.find do |name|
+          item =~ /^-+#{name.to_s.gsub(/[-_]/, '[-_]')}(?:[ =].*)?$/
+        end
+        if option
+          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('=')
+            index += 1 unless
+              (option.optional_argument? and command_line.args[index + 1] =~ /^-/)
+          end
+        else
+          option = find_global_settings_argument(item)
+          if option
+            unless Puppet.settings.boolean? option.name
+              # 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
+          else 
+            option = find_application_argument(item)
+            if option
+              index += 1 if (option[:argument] and not option[:optional])
+            else
+              raise OptionParser::InvalidOption.new(item.sub(/=.*$/, ''))
+            end
+          end
+        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?
+      @action = @face.get_default_action()
+      if @action
+        @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}`.") % { face: face, action: action }
+
+        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 %{arg}") % { face: face, arg: 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
+        raise ArgumentError, n_("puppet %{face} %{action} takes %{arg_count} argument, but you gave %{given_count}", "puppet %{face} %{action} takes %{arg_count} arguments, but you gave %{given_count}", arity - 1) % { face: @face.name, action: @action.name, arg_count: arity-1, given_count: count-1 }
+      end
+    end
+
+    if @face.deprecated?
+      Puppet.deprecation_warning(_("'puppet %{face}' is deprecated and will be removed in a future release") % { face: @face.name })
+    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} %{action}' for usage") % { face: @face.name, action: @action.name }
+
+  ensure
+    exit status
+  end
+end

data/lib/puppet/application/facts.rb

@@ -0,0 +1,9 @@
+require_relative '../../puppet/application/indirection_base'
+
+class Puppet::Application::Facts < Puppet::Application::IndirectionBase
+  # Allows `puppet facts` actions to be run against environments that
+  # don't exist locally, such as using the `--environment` flag to make a REST
+  # request to a specific environment on a master. There is no way to set this
+  # behavior per-action, so it must be set for the face as a whole.
+  environment_mode :not_required
+end

data/lib/puppet/application/filebucket.rb

@@ -0,0 +1,318 @@
+require_relative '../../puppet/application'
+
+class Puppet::Application::Filebucket < Puppet::Application
+  environment_mode :not_required
+
+  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 summary
+    _("Store and retrieve files in a filebucket")
+  end
+
+  def digest_algorithm
+    Puppet.default_digest_algorithm
+  end
+
+  def help
+    <<-HELP
+
+puppet-filebucket(8) -- #{summary}
+========
+
+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 #{digest_algorithm} sum.
+
+get:
+  Return the text associated with an #{digest_algorithm} sum. The text is printed to
+  stdout, and only one file can be retrieved at a time.
+
+restore:
+  Given a file path and an #{digest_algorithm} 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', or by specifying
+'--bucket' with a local path.
+
+> **Note**: Enabling and using the backup option, and by extension the 
+  filebucket resource, requires appropriate planning and management to ensure 
+  that sufficient disk space is available for the file backups. Generally, you 
+  can implement this using one of the following two options:
+  - Use a `find` command and `crontab` entry to retain only the last X days 
+  of file backups. For example: 
+
+  ```shell
+  find /opt/puppetlabs/server/data/puppetserver/bucket -type f -mtime +45 -atime +45 -print0 | xargs -0 rm
+  ```
+
+  - Restrict the directory to a maximum size after which the oldest items are removed.
+
+
+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://puppet.com/docs/puppet/latest/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'.
+
+* --bucket:
+  Specify a local filebucket path. This overrides the default path
+  set in '$clientbucketdir'.
+
+* --debug:
+  Enable full debugging.
+
+* --fromdate:
+  (list only) Select bucket files from 'fromdate'.
+
+* --help:
+  Print this help message.
+
+* --local:
+  Use the local filebucket. This uses the default configuration
+  information and the bucket located at the '$clientbucketdir'
+  setting by default. If '--bucket' is set, puppet uses that
+  path instead.
+
+* --remote:
+  Use a remote filebucket. This uses the default configuration
+  information and the bucket located at the '$bucketdir' setting
+  by default.
+
+* --server_list:
+  A list of comma separated servers; only the first entry is used for file storage.
+  This setting takes precidence over `server`.
+
+* --server:
+  The server to use for file storage. This setting is only used if `server_list`
+  is not set.
+
+* --todate:
+  (list only) Select bucket files until 'todate'.
+
+* --verbose:
+  Print extra information.
+
+* --version:
+  Print version information.
+
+EXAMPLES
+--------
+    ## Backup a file to the filebucket, then restore it to a temporary directory
+    $ 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 a local file
+    $ puppet filebucket -l diff d43a6ecaa892a1962398ac9170ea9bf2 /tmp/testFile
+    1a2
+    > again
+
+    ## Backup a file to the filebucket and observe that it keeps each backup separate
+    $ 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
+
+    ## List files in a filebucket within date ranges
+    $ 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
+    ## Manage files in a specific local filebucket
+    $ puppet filebucket -b /tmp/TestBucket backup /tmp/TestFile2
+    /tmp/TestFile2: d41d8cd98f00b204e9800998ecf8427e
+    $ puppet filebucket -b /tmp/TestBucket list
+    d41d8cd98f00b204e9800998ecf8427e 2015-05-11 09:33:22 /tmp/TestFile2
+
+    ## From a Puppet Server, list files in the server bucketdir
+    $ puppet filebucket -b $(puppet config print bucketdir --section server) list
+    d43a6ecaa892a1962398ac9170ea9bf2 2015-05-11 09:27:56 /tmp/TestFile
+    7ae322f5791217e031dc60188f4521ef 2015-05-11 09:52:15 /tmp/TestFile
+
+AUTHOR
+------
+Luke Kanies
+
+
+COPYRIGHT
+---------
+Copyright (c) 2011 Puppet Inc., 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
+    digest = args.shift
+    out = @client.getfile(digest)
+    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") % { file: file }
+        next
+      end
+      unless FileTest.readable?(file)
+        $stderr.puts _("%{file}: cannot read file") % { file: file }
+        next
+      end
+      digest = @client.backup(file)
+      puts "#{file}: #{digest}"
+    end
+  end
+
+  def list
+    fromdate = options[:fromdate]
+    todate = options[:todate]
+    out = @client.list(fromdate, todate)
+    print out
+  end
+
+  def restore
+    file = args.shift
+    digest = args.shift
+    @client.restore(file, digest)
+  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}") % { checksum_a: checksum_a, checksum_b: checksum_b, file_a: file_a, file_b: 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_relative '../../puppet/file_bucket/dipper'
+    begin
+      if options[:local] or options[:bucket]
+        path = options[:bucket] || Puppet[:clientbucketdir]
+        @client = Puppet::FileBucket::Dipper.new(:Path => path)
+      else
+        session = Puppet.lookup(:http_session)
+        api = session.route_to(:puppet)
+
+        @client = Puppet::FileBucket::Dipper.new(Server: api.url.host, Port: api.url.port)
+      end
+    rescue => detail
+      Puppet.log_exception(detail)
+      exit(1)
+    end
+  end
+end

data/lib/puppet/application/generate.rb

@@ -0,0 +1,5 @@
+require_relative '../../puppet/application/face_base'
+
+# The Generate application. 
+class Puppet::Application::Generate < Puppet::Application::FaceBase
+end

data/lib/puppet/application/help.rb

@@ -0,0 +1,5 @@
+require_relative '../../puppet/application/face_base'
+
+class Puppet::Application::Help < Puppet::Application::FaceBase
+  environment_mode :not_required
+end

data/lib/puppet/application/indirection_base.rb

@@ -0,0 +1,4 @@
+require_relative '../../puppet/application/face_base'
+
+class Puppet::Application::IndirectionBase < Puppet::Application::FaceBase
+end