openvox 8.19.0

data/lib/puppet/application/face_base.rb

@@ -0,0 +1,277 @@
+# frozen_string_literal: true
+
+require_relative '../../puppet/application'
+require_relative '../../puppet/face'
+require 'optparse'
+
+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
+      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 !(option[:optional])
+            else
+              raise OptionParser::InvalidOption, 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
+    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
+    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,11 @@
+# frozen_string_literal: true
+
+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,324 @@
+# frozen_string_literal: true
+
+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_reader :args
+
+  def summary
+    _("Store and retrieve files in an OpenVox filebucket")
+  end
+
+  def digest_algorithm
+    Puppet.default_digest_algorithm
+  end
+
+  def help
+    <<~HELP
+
+      puppet-filebucket(8) -- #{summary}
+      ========
+
+      SYNOPSIS
+      --------
+      A stand-alone OpenVox 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> ...
+
+      This filebucket client 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.
+
+      **Important**: When you enable and use the backup option, and by extension
+      the filebucket resource, you must ensure that sufficient disk space is
+      available for the file backups. Generally, you can provide the disk space
+      by 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, that path is used 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.
+      Copyright (c) 2024 Vox Pupuli
+      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,7 @@
+# frozen_string_literal: true
+
+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,7 @@
+# frozen_string_literal: true
+
+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,6 @@
+# frozen_string_literal: true
+
+require_relative '../../puppet/application/face_base'
+
+class Puppet::Application::IndirectionBase < Puppet::Application::FaceBase
+end