bolt 0.20.0 → 0.20.2

data/vendored/puppet/lib/puppet/application/certificate.rb

@@ -0,0 +1,17 @@
+require 'puppet/application/indirection_base'
+require 'puppet/ssl/oids'
+
+class Puppet::Application::Certificate < Puppet::Application::IndirectionBase
+  def setup
+    Puppet::SSL::Oids.register_puppet_oids
+    location = Puppet::SSL::Host.ca_location
+    if location == :local && !Puppet::SSL::CertificateAuthority.ca?
+      # I'd prefer if this could be dealt with differently; ideally, run_mode should be set as
+      #  part of a class definition, and should not be modifiable beyond that.  This is one of
+      #  the cases where that isn't currently possible.
+      Puppet.settings.preferred_run_mode = "master"
+    end
+
+    super
+  end
+end

data/vendored/puppet/lib/puppet/application/certificate_request.rb

@@ -0,0 +1,7 @@
+require 'puppet/application/indirection_base'
+
+# NOTE: this is using an "old" naming convention (underscores instead of camel-case), for backwards
+#  compatibility with 2.7.x.  When the old naming convention is officially and publicly deprecated,
+#  this should be changed to camel-case.
+class Puppet::Application::Certificate_request < Puppet::Application::IndirectionBase
+end

data/vendored/puppet/lib/puppet/application/certificate_revocation_list.rb

@@ -0,0 +1,7 @@
+require 'puppet/application/indirection_base'
+
+# NOTE: this is using an "old" naming convention (underscores instead of camel-case), for backwards
+#  compatibility with 2.7.x.  When the old naming convention is officially and publicly deprecated,
+#  this should be changed to camel-case.
+class Puppet::Application::Certificate_revocation_list < Puppet::Application::IndirectionBase
+end

data/vendored/puppet/lib/puppet/application/config.rb

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

data/vendored/puppet/lib/puppet/application/describe.rb

@@ -0,0 +1,257 @@
+require 'puppet/application'
+
+class Formatter
+
+  def initialize(width)
+    @width = width
+  end
+
+  def wrap(txt, opts)
+    return "" unless txt && !txt.empty?
+    work = (opts[:scrub] ? scrub(txt) : txt)
+    indent = (opts[:indent] ? opts[:indent] : 0)
+    textLen = @width - indent
+    patt = Regexp.new("\\A(.{0,#{textLen}})[ \n]")
+    prefix = " " * indent
+
+    res = []
+
+    while work.length > textLen
+      if work =~ patt
+        res << $1
+        work.slice!(0, $MATCH.length)
+      else
+        res << work.slice!(0, textLen)
+      end
+    end
+    res << work if work.length.nonzero?
+    prefix + res.join("\n#{prefix}")
+  end
+
+  def header(txt, sep = "-")
+    "\n#{txt}\n" + sep * txt.size
+  end
+
+  private
+
+  def scrub(text)
+    # For text with no carriage returns, there's nothing to do.
+    return text if text !~ /\n/
+
+    # If we can match an indentation, then just remove that same level of
+    # indent from every line.
+    if text =~ /^(\s+)/
+      indent = $1
+      return text.gsub(/^#{indent}/,'')
+    else
+      return text
+    end
+  end
+
+end
+
+class TypeDoc
+
+  def initialize
+    @format = Formatter.new(76)
+    @types = {}
+    Puppet::Type.loadall
+    Puppet::Type.eachtype { |type|
+      next if type.name == :component
+      @types[type.name] = type
+    }
+  end
+
+  def list_types
+    puts "These are the types known to puppet:\n"
+    @types.keys.sort { |a, b|
+      a.to_s <=> b.to_s
+    }.each do |name|
+      type = @types[name]
+      s = type.doc.gsub(/\s+/, " ")
+      n = s.index(". ")
+      if n.nil?
+        s = ".. no documentation .."
+      elsif n > 45
+        s = s[0, 45] + " ..."
+      else
+        s = s[0, n]
+      end
+      printf "%-15s - %s\n", name, s
+    end
+  end
+
+  def format_type(name, opts)
+    name = name.to_sym
+    unless @types.has_key?(name)
+      puts "Unknown type #{name}"
+      return
+    end
+    type = @types[name]
+    puts @format.header(name.to_s, "=")
+    puts @format.wrap(type.doc, :indent => 0, :scrub => true) + "\n\n"
+
+    puts @format.header("Parameters")
+    if opts[:parameters]
+      format_attrs(type, [:property, :param])
+    else
+      list_attrs(type, [:property, :param])
+    end
+
+    if opts[:meta]
+      puts @format.header("Meta Parameters")
+      if opts[:parameters]
+        format_attrs(type, [:meta])
+      else
+        list_attrs(type, [:meta])
+      end
+    end
+
+    if type.providers.size > 0
+      puts @format.header("Providers")
+      if opts[:providers]
+        format_providers(type)
+      else
+        list_providers(type)
+      end
+    end
+  end
+
+  # List details about attributes
+  def format_attrs(type, attrs)
+    docs = {}
+    type.allattrs.each do |name|
+      kind = type.attrtype(name)
+      docs[name] = type.attrclass(name).doc if attrs.include?(kind) && name != :provider
+    end
+
+    docs.sort { |a,b|
+      a[0].to_s <=> b[0].to_s
+    }.each { |name, doc|
+      print "\n- **#{name}**"
+      if type.key_attributes.include?(name) and name != :name
+        puts " (*namevar*)"
+      else
+        puts ""
+      end
+      puts @format.wrap(doc, :indent => 4, :scrub => true)
+    }
+  end
+
+  # List the names of attributes
+  def list_attrs(type, attrs)
+    params = []
+    type.allattrs.each do |name|
+      kind = type.attrtype(name)
+      params << name.to_s if attrs.include?(kind) && name != :provider
+    end
+    puts @format.wrap(params.sort.join(", "), :indent => 4)
+  end
+
+  def format_providers(type)
+    type.providers.sort { |a,b|
+      a.to_s <=> b.to_s
+    }.each { |prov|
+      puts "\n- **#{prov}**"
+      puts @format.wrap(type.provider(prov).doc, :indent => 4, :scrub => true)
+    }
+  end
+
+  def list_providers(type)
+    list = type.providers.sort { |a,b|
+      a.to_s <=> b.to_s
+    }.join(", ")
+    puts @format.wrap(list, :indent => 4)
+  end
+
+end
+
+class Puppet::Application::Describe < Puppet::Application
+  banner "puppet describe [options] [type]"
+
+  option("--short", "-s", "Only list parameters without detail") do |arg|
+    options[:parameters] = false
+  end
+
+  option("--providers","-p")
+  option("--list", "-l")
+  option("--meta","-m")
+
+  def summary
+    _("Display help about resource types")
+  end
+
+  def help
+    <<-HELP
+
+puppet-describe(8) -- #{summary}
+========
+
+SYNOPSIS
+--------
+Prints help about Puppet resource types, providers, and metaparameters.
+
+
+USAGE
+-----
+puppet describe [-h|--help] [-s|--short] [-p|--providers] [-l|--list] [-m|--meta]
+
+
+OPTIONS
+-------
+* --help:
+  Print this help text
+
+* --providers:
+  Describe providers in detail for each type
+
+* --list:
+  List all types
+
+* --meta:
+  List all metaparameters
+
+* --short:
+  List only parameters without detail
+
+
+EXAMPLE
+-------
+    $ puppet describe --list
+    $ puppet describe file --providers
+    $ puppet describe user -s -m
+
+
+AUTHOR
+------
+David Lutterkort
+
+
+COPYRIGHT
+---------
+Copyright (c) 2011 Puppet Inc., LLC Licensed under the Apache 2.0 License
+
+    HELP
+  end
+
+  def preinit
+    options[:parameters] = true
+  end
+
+  def main
+    doc = TypeDoc.new
+
+    if options[:list]
+      doc.list_types
+    else
+      options[:types].each { |name| doc.format_type(name, options) }
+    end
+  end
+
+  def setup
+    options[:types] = command_line.args.dup
+    handle_help(nil) unless options[:list] || options[:types].size > 0
+    $stderr.puts "Warning: ignoring types when listing all types" if options[:list] && options[:types].size > 0
+  end
+
+end

data/vendored/puppet/lib/puppet/application/device.rb

@@ -0,0 +1,378 @@
+require 'puppet/application'
+require 'puppet/util/network_device'
+
+class Puppet::Application::Device < Puppet::Application
+
+  run_mode :agent
+
+  attr_accessor :args, :agent, :host
+
+  def app_defaults
+    super.merge({
+      :catalog_terminus => :rest,
+      :catalog_cache_terminus => :json,
+      :node_terminus => :rest,
+      :facts_terminus => :network_device,
+    })
+  end
+
+  def preinit
+    # Do an initial trap, so that cancels don't get a stack trace.
+    Signal.trap(:INT) do
+      $stderr.puts _("Cancelling startup")
+      exit(0)
+    end
+
+    {
+      :apply => nil,
+      :waitforcert => nil,
+      :detailed_exitcodes => false,
+      :verbose => false,
+      :debug => false,
+      :centrallogs => false,
+      :setdest => false,
+      :resource => false,
+      :target => nil,
+      :to_yaml => false,
+    }.each do |opt,val|
+      options[opt] = val
+    end
+
+    @args = {}
+  end
+
+  option("--centrallogging")
+  option("--debug","-d")
+  option("--resource","-r")
+  option("--to_yaml","-y")
+  option("--verbose","-v")
+
+  option("--detailed-exitcodes") do |arg|
+    options[:detailed_exitcodes] = true
+  end
+
+  option("--apply MANIFEST") do |arg|
+    options[:apply] = arg.to_s
+  end
+
+  option("--logdest DEST", "-l DEST") do |arg|
+    handle_logdest_arg(arg)
+  end
+
+  option("--waitforcert WAITFORCERT", "-w") do |arg|
+    options[:waitforcert] = arg.to_i
+  end
+
+  option("--port PORT","-p") do |arg|
+    @args[:Port] = arg
+  end
+
+  option("--target DEVICE", "-t") do |arg|
+    options[:target] = arg.to_s
+  end
+
+  def summary
+    _("Manage remote network devices")
+  end
+
+  def help
+      <<-HELP
+
+puppet-device(8) -- #{summary}
+========
+
+SYNOPSIS
+--------
+Retrieves catalogs from the Puppet master and applies them to remote devices. 
+
+This subcommand can be run manually; or periodically using cron,
+a scheduled task, or a similar tool.
+
+
+USAGE
+-----
+  puppet device [-d|--debug] [--detailed-exitcodes] [--deviceconfig <file>]
+                [-h|--help] [-l|--logdest syslog|<file>|console]
+                [-v|--verbose] [-w|--waitforcert <seconds>]
+                [-a|--apply <file>] [-r|--resource <type> [name]]
+                [-t|--target <device>] [--user=<user>] [-V|--version]
+
+
+DESCRIPTION
+-----------
+Devices require a proxy Puppet agent to request certificates, collect facts,
+retrieve and apply catalogs, and store reports.
+
+
+USAGE NOTES
+-----------
+Devices managed by the puppet-device subcommand on a Puppet agent are 
+configured in device.conf, which is located at $confdir/device.conf by default, 
+and is configurable with the $deviceconfig setting. 
+
+The device.conf file is an INI-like file, with one section per device:
+
+[<DEVICE_CERTNAME>]
+type <TYPE>
+url <URL>
+debug
+
+The section name specifies the certname of the device. 
+
+The values for the type and url properties are specific to each type of device.
+
+The optional debug property specifies transport-level debugging,
+and is limited to telnet and ssh transports.
+
+See https://docs.puppet.com/puppet/latest/config_file_device.html for details.
+
+
+OPTIONS
+-------
+Note that any setting that's valid in the configuration file is also a valid 
+long argument. For example, 'server' is a valid configuration parameter, so 
+you can specify '--server <servername>' as an argument.
+
+* --debug:
+  Enable full debugging.
+
+* --detailed-exitcodes:
+  Provide transaction information via exit codes. If this is enabled, an exit
+  code of '1' means at least one device had a compile failure, an exit code of
+  '2' means at least one device had resource changes, and an exit code of '4'
+  means at least one device had resource failures. Exit codes of '3', '5', '6',
+  or '7' means that a bitwise combination of the preceding exit codes happened.
+
+* --deviceconfig:
+  Path to the device config file for puppet device.
+  Default: $confdir/device.conf
+
+* --help:
+  Print this help message
+
+* --logdest:
+  Where to send log messages. Choose between 'syslog' (the POSIX syslog
+  service), 'console', or the path to a log file. If debugging or verbosity is
+  enabled, this defaults to 'console'. Otherwise, it defaults to 'syslog'.
+
+  A path ending with '.json' will receive structured output in JSON format. The
+  log file will not have an ending ']' automatically written to it due to the
+  appending nature of logging. It must be appended manually to make the content
+  valid JSON.
+
+* --apply:
+  Apply a manifest against a remote target. Target must be specified.
+
+* --resource:
+  Displays a resource state as Puppet code, roughly equivalent to
+  `puppet resource`.  Can be filterd by title. Requires --target be specified.
+
+* --target:
+  Target a specific device/certificate in the device.conf. Doing so will perform a
+  device run against only that device/certificate.
+
+* --to_yaml:
+  Output found resources in yaml format, suitable to use with Hiera and
+  create_resources.
+
+* --user:
+  The user to run as.
+
+* --verbose:
+  Turn on verbose reporting.
+
+* --waitforcert:
+  This option only matters for daemons that do not yet have certificates
+  and it is enabled by default, with a value of 120 (seconds).  This causes
+  +puppet agent+ to connect to the server every 2 minutes and ask it to sign a
+  certificate request.  This is useful for the initial setup of a puppet
+  client.  You can turn off waiting for certificates by specifying a time of 0.
+
+
+EXAMPLE
+-------
+      $ puppet device --target remotehost --verbose
+
+AUTHOR
+------
+Brice Figureau
+
+
+COPYRIGHT
+---------
+Copyright (c) 2011 Puppet Inc., LLC
+Licensed under the Apache 2.0 License
+      HELP
+  end
+
+
+  def main
+    if options[:resource] and !options[:target]
+      Puppet.err _("resource command requires target")
+      exit(1)
+    end
+    unless options[:apply].nil?
+      if options[:target].nil?
+        Puppet.err _("missing argument: --target is required when using --apply")
+        exit(1)
+      end
+      unless File.file?(options[:apply])
+        Puppet.err _("%{file} does not exist, cannot apply") % { file: options[:apply] }
+        exit(1)
+      end
+    end
+    vardir = Puppet[:vardir]
+    confdir = Puppet[:confdir]
+    certname = Puppet[:certname]
+
+    env = Puppet.lookup(:environments).get(Puppet[:environment])
+    returns = Puppet.override(:current_environment => env, :loaders => Puppet::Pops::Loaders.new(env)) do
+      # find device list
+      require 'puppet/util/network_device/config'
+      devices = Puppet::Util::NetworkDevice::Config.devices.dup
+      if options[:target]
+        devices.select! { |key, value| key == options[:target] }
+      end
+      if devices.empty?
+        if options[:target]
+          Puppet.err _("Target device / certificate '%{target}' not found in %{config}") % { target: options[:target], config: Puppet[:deviceconfig] }
+        else
+          Puppet.err _("No device found in %{config}") % { config: Puppet[:deviceconfig] }
+          exit(1)
+        end
+      end
+      devices.collect do |devicename,device|
+        begin
+          device_url = URI.parse(device.url)
+          # Handle nil scheme & port
+          scheme = "#{device_url.scheme}://" if device_url.scheme
+          port = ":#{device_url.port}" if device_url.port
+
+          # override local $vardir and $certname
+          Puppet[:confdir] = ::File.join(Puppet[:devicedir], device.name)
+          Puppet[:vardir] = ::File.join(Puppet[:devicedir], device.name)
+          Puppet[:certname] = device.name
+
+          # this init the device singleton, so that the facts terminus
+          # and the various network_device provider can use it
+          Puppet::Util::NetworkDevice.init(device)
+
+          if options[:resource]
+            type, name = parse_args(command_line.args)
+            Puppet.info _("retrieving resource: %{resource} from %{target} at %{scheme}%{url_host}%{port}%{url_path}") % { resource: type, target: device.name, scheme: scheme, url_host: device_url.host, port: port, url_path: device_url.path }
+
+            resources = find_resources(type, name)
+
+            if options[:to_yaml]
+              text = resources.map do |resource|
+                resource.prune_parameters(:parameters_to_include => @extra_params).to_hierayaml.force_encoding(Encoding.default_external)
+              end.join("\n")
+              text.prepend("#{type.downcase}:\n")
+            else
+              text = resources.map do |resource|
+                resource.prune_parameters(:parameters_to_include => @extra_params).to_manifest.force_encoding(Encoding.default_external)
+              end.join("\n")
+            end
+            (puts text)
+          elsif options[:apply]
+            # avoid reporting to server
+            Puppet::Transaction::Report.indirection.terminus_class = :yaml
+            Puppet::Resource::Catalog.indirection.cache_class = nil
+
+            require 'puppet/application/apply'
+            begin
+
+              Puppet[:node_terminus] = :plain
+              Puppet[:catalog_terminus] = :compiler
+              Puppet[:catalog_cache_terminus] = nil
+              Puppet[:facts_terminus] = :network_device
+              Puppet.override(:network_device => true) do
+                Puppet::Application::Apply.new(Puppet::Util::CommandLine.new('puppet', ["apply", options[:apply]])).run_command
+              end
+            end
+          else
+            Puppet.info _("starting applying configuration to %{target} at %{scheme}%{url_host}%{port}%{url_path}") % { target: device.name, scheme: scheme, url_host: device_url.host, port: port, url_path: device_url.path }
+            # this will reload and recompute default settings and create the devices sub vardir
+            Puppet.settings.use :main, :agent, :ssl
+            # ask for a ssl cert if needed, but at least
+            # setup the ssl system for this device.
+            setup_host
+
+            require 'puppet/configurer'
+            configurer = Puppet::Configurer.new
+            configurer.run(:network_device => true, :pluginsync => Puppet::Configurer.should_pluginsync?)
+          end
+        rescue => detail
+          Puppet.log_exception(detail)
+          # If we rescued an error, then we return 1 as the exit code
+          1
+        ensure
+          Puppet[:vardir] = vardir
+          Puppet[:confdir] = confdir
+          Puppet[:certname] = certname
+          Puppet::SSL::Host.reset
+        end
+      end
+    end
+
+    if ! returns or returns.compact.empty?
+      exit(1)
+    elsif options[:detailed_exitcodes]
+      # Bitwise OR the return codes together, puppet style
+      exit(returns.compact.reduce(:|))
+    elsif returns.include? 1
+      exit(1)
+    else
+      exit(0)
+    end
+  end
+
+  def parse_args(args)
+    type = args.shift or raise _("You must specify the type to display")
+    Puppet::Type.type(type) or raise _("Could not find type %{type}") % { type: type }
+    name = args.shift
+
+    [type, name]
+  end
+
+  def find_resources(type, name)
+    key = [type, name].join('/')
+
+    if name
+      [ Puppet::Resource.indirection.find( key ) ]
+    else
+      Puppet::Resource.indirection.search( key, {} )
+    end
+  end
+
+  def setup_host
+    @host = Puppet::SSL::Host.new
+    waitforcert = options[:waitforcert] || (Puppet[:onetime] ? 0 : Puppet[:waitforcert])
+    @host.wait_for_cert(waitforcert)
+  end
+
+  def setup
+    setup_logs
+
+    args[:Server] = Puppet[:server]
+    if options[:centrallogs]
+      logdest = args[:Server]
+
+      logdest += ":" + args[:Port] if args.include?(:Port)
+      Puppet::Util::Log.newdestination(logdest)
+    end
+
+    Puppet.settings.use :main, :agent, :device, :ssl
+
+    # We need to specify a ca location for all of the SSL-related
+    # indirected classes to work; in fingerprint mode we just need
+    # access to the local files and we don't need a ca.
+    Puppet::SSL::Host.ca_location = :remote
+
+    Puppet::Transaction::Report.indirection.terminus_class = :rest
+
+    if Puppet[:catalog_cache_terminus]
+      Puppet::Resource::Catalog.indirection.cache_class = Puppet[:catalog_cache_terminus].intern
+    end
+  end
+end