bolt 0.19.1 → 0.20.0

data/vendored/puppet/lib/puppet/provider/zpool/zpool.rb

@@ -1,125 +0,0 @@
-Puppet::Type.type(:zpool).provide(:zpool) do
-  desc "Provider for zpool."
-
-  commands :zpool => 'zpool'
-
-  #NAME    SIZE  ALLOC   FREE    CAP  HEALTH  ALTROOT
-  def self.instances
-    zpool(:list, '-H').split("\n").collect do |line|
-      name, _size, _alloc, _free, _cap, _health, _altroot = line.split(/\s+/)
-      new({:name => name, :ensure => :present})
-    end
-  end
-
-  def process_zpool_data(pool_array)
-    if pool_array == []
-      return Hash.new(:absent)
-    end
-    #get the name and get rid of it
-    pool = Hash.new
-    pool[:pool] = pool_array[0]
-    pool_array.shift
-
-    tmp = []
-
-    #order matters here :(
-    pool_array.reverse_each do |value|
-      sym = nil
-      case value
-      when "spares";
-        sym = :spare
-      when "logs";
-        sym = :log
-      when /^mirror|^raidz1|^raidz2/;
-        sym = value =~ /^mirror/ ? :mirror : :raidz
-        pool[:raid_parity] = "raidz2" if value =~ /^raidz2/
-      else
-        tmp << value
-        sym = :disk if value == pool_array.first
-      end
-
-      if sym
-        pool[sym] = pool[sym] ? pool[sym].unshift(tmp.reverse.join(' ')) : [tmp.reverse.join(' ')]
-        tmp.clear
-      end
-    end
-
-    pool
-  end
-
-  def get_pool_data
-    # https://docs.oracle.com/cd/E19082-01/817-2271/gbcve/index.html
-    # we could also use zpool iostat -v mypool for a (little bit) cleaner output
-    out = execute("zpool status #{@resource[:pool]}", :failonfail => false, :combine => false)
-    zpool_data = out.lines.select { |line| line.index("\t") == 0 }.collect { |l| l.strip.split("\s")[0] }
-    zpool_data.shift
-    zpool_data
-  end
-
-  def current_pool
-    @current_pool = process_zpool_data(get_pool_data) unless (defined?(@current_pool) and @current_pool)
-    @current_pool
-  end
-
-  def flush
-    @current_pool= nil
-  end
-
-  #Adds log and spare
-  def build_named(name)
-    if prop = @resource[name.intern]
-      [name] + prop.collect { |p| p.split(' ') }.flatten
-    else
-      []
-    end
-  end
-
-  #query for parity and set the right string
-  def raidzarity
-    @resource[:raid_parity] ? @resource[:raid_parity] : "raidz1"
-  end
-
-  #handle mirror or raid
-  def handle_multi_arrays(prefix, array)
-    array.collect{ |a| [prefix] +  a.split(' ') }.flatten
-  end
-
-  #builds up the vdevs for create command
-  def build_vdevs
-    if disk = @resource[:disk]
-      disk.collect { |d| d.split(' ') }.flatten
-    elsif mirror = @resource[:mirror]
-      handle_multi_arrays("mirror", mirror)
-    elsif raidz = @resource[:raidz]
-      handle_multi_arrays(raidzarity, raidz)
-    end
-  end
-
-  def create
-    zpool(*([:create, @resource[:pool]] + build_vdevs + build_named("spare") + build_named("log")))
-  end
-
-  def destroy
-    zpool :destroy, @resource[:pool]
-  end
-
-  def exists?
-    if current_pool[:pool] == :absent
-      false
-    else
-      true
-    end
-  end
-
-  [:disk, :mirror, :raidz, :log, :spare].each do |field|
-    define_method(field) do
-      current_pool[field]
-    end
-
-    define_method(field.to_s + "=") do |should|
-      self.fail "zpool #{field} can't be changed. should be #{should}, currently is #{current_pool[field]}"
-    end
-  end
-
-end
-

data/vendored/puppet/lib/puppet/reference/configuration.rb

@@ -1,86 +0,0 @@
-config = Puppet::Util::Reference.newreference(:configuration, :depth => 1, :doc => "A reference for all settings") do
-  docs = {}
-  Puppet.settings.each do |name, object|
-    docs[name] = object
-  end
-
-  str = ""
-  docs.sort { |a, b|
-    a[0].to_s <=> b[0].to_s
-  }.each do |name, object|
-    # Make each name an anchor
-    header = name.to_s
-    str << markdown_header(header, 3)
-
-    # Print the doc string itself
-    begin
-      str << Puppet::Util::Docs.scrub(object.desc)
-    rescue => detail
-      Puppet.log_exception(detail)
-    end
-    str << "\n\n"
-
-    # Now print the data about the item.
-    val = object.default
-    if name.to_s == 'vardir'
-      val = 'Unix/Linux: /opt/puppetlabs/puppet/cache -- Windows: C:\ProgramData\PuppetLabs\puppet\cache -- Non-root user: ~/.puppetlabs/opt/puppet/cache'
-    elsif name.to_s == 'confdir'
-      val = 'Unix/Linux: /etc/puppetlabs/puppet -- Windows: C:\ProgramData\PuppetLabs\puppet\etc -- Non-root user: ~/.puppetlabs/etc/puppet'
-    elsif name.to_s == 'codedir'
-      val = 'Unix/Linux: /etc/puppetlabs/code -- Windows: C:\ProgramData\PuppetLabs\code -- Non-root user: ~/.puppetlabs/etc/code'
-    elsif name.to_s == 'rundir'
-      val = 'Unix/Linux: /var/run/puppetlabs -- Windows: C:\ProgramData\PuppetLabs\puppet\var\run -- Non-root user: ~/.puppetlabs/var/run'
-    elsif name.to_s == 'logdir'
-      val = 'Unix/Linux: /var/log/puppetlabs/puppet -- Windows: C:\ProgramData\PuppetLabs\puppet\var\log -- Non-root user: ~/.puppetlabs/var/log'
-    elsif name.to_s == 'hiera_config'
-      val = '$confdir/hiera.yaml. However, if a file exists at $codedir/hiera.yaml, Puppet uses that instead.'
-    elsif name.to_s == 'certname'
-      val = "the Host's fully qualified domain name, as determined by facter"
-    end
-
-    # Leave out the section information; it was apparently confusing people.
-    #str << "- **Section**: #{object.section}\n"
-    unless val == ""
-      str << "- *Default*: #{val}\n"
-    end
-    str << "\n"
-  end
-
-  return str
-end
-
-config.header = <<EOT
-## Configuration settings
-
-* Each of these settings can be specified in `puppet.conf` or on the
-  command line.
-* When using boolean settings on the command line, use `--setting` and
-  `--no-setting` instead of `--setting (true|false)`. (Using `--setting false`
-  results in "Error: Could not parse application options: needless argument".)
-* Settings can be interpolated as `$variables` in other settings; `$environment`
-  is special, in that puppet master will interpolate each agent node's
-  environment instead of its own.
-* Multiple values should be specified as comma-separated lists; multiple
-  directories should be separated with the system path separator (usually
-  a colon).
-* Settings that represent time intervals should be specified in duration format:
-  an integer immediately followed by one of the units 'y' (years of 365 days),
-  'd' (days), 'h' (hours), 'm' (minutes), or 's' (seconds). The unit cannot be
-  combined with other units, and defaults to seconds when omitted. Examples are
-  '3600' which is equivalent to '1h' (one hour), and '1825d' which is equivalent
-  to '5y' (5 years).
-* If you use the `splay` setting, note that the period that it waits changes
-  each time the Puppet agent is restarted.
-* Settings that take a single file or directory can optionally set the owner,
-  group, and mode for their value: `rundir = $vardir/run { owner = puppet,
-  group = puppet, mode = 644 }`
-* The Puppet executables will ignore any setting that isn't relevant to
-  their function.
-
-See the [configuration guide][confguide] for more details.
-
-[confguide]: https://puppet.com/docs/puppet/latest/config_about_settings.html
-
-* * *
-
-EOT

data/vendored/puppet/lib/puppet/reference/function.rb

@@ -1,17 +0,0 @@
-function = Puppet::Util::Reference.newreference :function, :doc => "All functions available in the parser" do
-  Puppet::Parser::Functions.functiondocs
-end
-function.header = "
-There are two types of functions in Puppet: Statements and rvalues.
-Statements stand on their own and do not return arguments; they are used for
-performing stand-alone work like importing.  Rvalues return values and can
-only be used in a statement requiring a value, such as an assignment or a case
-statement.
-
-Functions execute on the Puppet master.  They do not execute on the Puppet agent.
-Hence they only have access to the commands and data available on the Puppet master
-host.
-
-Here are the functions available in Puppet:
-
-"

data/vendored/puppet/lib/puppet/reference/indirection.rb

@@ -1,71 +0,0 @@
-require 'puppet/indirector/indirection'
-require 'puppet/util/checksums'
-require 'puppet/file_serving/content'
-require 'puppet/file_serving/metadata'
-
-reference = Puppet::Util::Reference.newreference :indirection, :doc => "Indirection types and their terminus classes" do
-  text = ""
-  Puppet::Indirector::Indirection.instances.sort { |a,b| a.to_s <=> b.to_s }.each do |indirection|
-    ind = Puppet::Indirector::Indirection.instance(indirection)
-    name = indirection.to_s.capitalize
-    text << "## " + indirection.to_s + "\n\n"
-
-    text << Puppet::Util::Docs.scrub(ind.doc) + "\n\n"
-
-    Puppet::Indirector::Terminus.terminus_classes(ind.name).sort { |a,b| a.to_s <=> b.to_s }.each do |terminus|
-      terminus_name = terminus.to_s
-      term_class = Puppet::Indirector::Terminus.terminus_class(ind.name, terminus)
-      if term_class
-        terminus_doc = Puppet::Util::Docs.scrub(term_class.doc)
-        text << markdown_header("`#{terminus_name}` terminus", 3) << terminus_doc << "\n\n"
-      else
-        Puppet.warning _("Could not build docs for indirector %{name}, terminus %{terminus}: could not locate terminus.") % { name: name.inspect, terminus: terminus_name.inspect }
-      end
-    end
-  end
-
-  text
-end
-
-reference.header = <<HEADER
-
-## About Indirection
-
-Puppet's indirector support pluggable backends (termini) for a variety of key-value stores (indirections).
-Each indirection type corresponds to a particular Ruby class (the "Indirected Class" below) and values are instances of that class.
-Each instance's key is available from its `name` method.
-The termini can be local (e.g., on-disk files) or remote (e.g., using a REST interface to talk to a puppet master).
-
-An indirector has five methods, which are mapped into HTTP verbs for the REST interface:
-
-* `find(key)` - get a single value (mapped to GET or POST with a singular endpoint)
-* `search(key)` - get a list of matching values (mapped to GET with a plural endpoint)
-* `head(key)` - return true if the key exists (mapped to HEAD)
-* `destroy(key)` - remove the key and value (mapped to DELETE)
-* `save(instance)` - write the instance to the store, using the instance's name as the key (mapped to PUT)
-
-These methods are available via the `indirection` class method on the indirected classes.  For example:
-
-    foo_cert = Puppet::SSL::Certificate.indirection.find('foo.example.com')
-
-At startup, each indirection is configured with a terminus.
-In most cases, this is the default terminus defined by the indirected class, but it can be overridden by the application or face, or overridden with the `route_file` configuration.
-The available termini differ for each indirection, and are listed below.
-
-Indirections can also have a cache, represented by a second terminus.
-This is a write-through cache: modifications are written both to the cache and to the primary terminus.
-Values fetched from the terminus are written to the cache.
-
-### Interaction with REST
-
-REST endpoints have the form `/{prefix}/{version}/{indirection}/{key}?environment={environment}`, where the indirection can be singular or plural, following normal English spelling rules.
-On the server side, REST responses are generated from the locally-configured endpoints.
-
-### Indirections and Termini
-
-Below is the list of all indirections, their associated terminus classes, and how you select between them.
-
-In general, the appropriate terminus class is selected by the application for you (e.g., `puppet agent` would always use the `rest`
-terminus for most of its indirected classes), but some classes are tunable via normal settings.  These will have `terminus setting` documentation listed with them.
-
-HEADER

data/vendored/puppet/lib/puppet/reference/metaparameter.rb

@@ -1,35 +0,0 @@
-Puppet::Util::Reference.newreference :metaparameter, :doc => "All Puppet metaparameters and all their details" do
-  str = %{
-
-Metaparameters are attributes that work with any resource type, including custom
-types and defined types.
-
-In general, they affect _Puppet's_ behavior rather than the desired state of the
-resource. Metaparameters do things like add metadata to a resource (`alias`,
-`tag`), set limits on when the resource should be synced (`require`, `schedule`,
-etc.), prevent Puppet from making changes (`noop`), and change logging verbosity
-(`loglevel`).
-
-## Available Metaparameters
-
-}
-  begin
-    params = []
-    Puppet::Type.eachmetaparam { |param|
-      params << param
-    }
-
-    params.sort { |a,b|
-      a.to_s <=> b.to_s
-    }.each { |param|
-      str << markdown_header(param.to_s, 3)
-      str << scrub(Puppet::Type.metaparamdoc(param))
-      str << "\n\n"
-    }
-  rescue => detail
-    Puppet.log_exception(detail, _("incorrect metaparams: %{detail}") % { detail: detail })
-    exit(1)
-  end
-
-  str
-end

data/vendored/puppet/lib/puppet/reference/providers.rb

@@ -1,118 +0,0 @@
-providers = Puppet::Util::Reference.newreference :providers, :title => "Provider Suitability Report", :depth => 1, :dynamic => true, :doc => "Which providers are valid for this machine" do
-  types = []
-  Puppet::Type.loadall
-  Puppet::Type.eachtype do |klass|
-    next unless klass && klass.providers.length > 0
-    types << klass
-  end
-  types.sort! { |a,b| a.name.to_s <=> b.name.to_s }
-
-  command_line = Puppet::Util::CommandLine.new
-  types.reject! { |type| ! command_line.args.include?(type.name.to_s) } unless command_line.args.empty?
-
-  ret = "Details about this host:\n\n"
-
-  # Throw some facts in there, so we know where the report is from.
-  ["Ruby Version", "Puppet Version", "Operating System", "Operating System Release"].each do |label|
-    name = label.gsub(/\s+/, '')
-    value = Facter.value(name)
-    ret << option(label, value)
-  end
-  ret << "\n"
-
-  count = 1
-
-  # Produce output for each type.
-  types.each do |type|
-    features = type.features
-    ret << "\n" # add a trailing newline
-
-    # Now build up a table of provider suitability.
-    headers = %w{Provider Suitable?} + features.collect { |f| f.to_s }.sort
-
-    table_data = {}
-
-    functional = false
-    notes = []
-    default = type.defaultprovider ? type.defaultprovider.name : 'none'
-    type.providers.sort { |a,b| a.to_s <=> b.to_s }.each do |pname|
-      data = []
-      table_data[pname] = data
-      provider = type.provider(pname)
-
-      # Add the suitability note
-      if missing = provider.suitable?(false) and missing.empty?
-        data << "*X*"
-        suit = true
-        functional = true
-      else
-        data << "[#{count}]_" # A pointer to the appropriate footnote
-        suit = false
-      end
-
-      # Add a footnote with the details about why this provider is unsuitable, if that's the case
-      unless suit
-        details = ".. [#{count}]\n"
-        missing.each do |test, values|
-          case test
-          when :exists
-            details << _("  - Missing files %{files}\n") % { files: values.join(", ") }
-          when :variable
-            values.each do |name, facts|
-              if Puppet.settings.valid?(name)
-                details << _("  - Setting %{name} (currently %{value}) not in list %{facts}\n") % { name: name, value: Puppet.settings.value(name).inspect, facts: facts.join(", ") }
-              else
-                details << _("  - Fact %{name} (currently %{value}) not in list %{facts}\n") % { name: name, value: Facter.value(name).inspect, facts: facts.join(", ") }
-              end
-            end
-          when :true
-            details << _("  - Got %{values} true tests that should have been false\n") % { values: values }
-          when :false
-            details << _("  - Got %{values} false tests that should have been true\n") % { values: values }
-          when :feature
-            details << _("  - Missing features %{values}\n") % { values: values.collect { |f| f.to_s }.join(",") }
-          end
-        end
-        notes << details
-
-        count += 1
-      end
-
-      # Add a note for every feature
-      features.each do |feature|
-        if provider.features.include?(feature)
-          data << "*X*"
-        else
-          data << ""
-        end
-      end
-    end
-
-    ret << markdown_header(type.name.to_s + "_", 2)
-
-    ret << "[#{type.name}](https://docs.puppetlabs.com/puppet/latest/reference/type.html##{type.name})\n\n"
-    ret << option("Default provider", default)
-    ret << doctable(headers, table_data)
-
-    notes.each do |note|
-      ret << note + "\n"
-    end
-
-    ret << "\n"
-  end
-
-  ret << "\n"
-
-  ret
-end
-providers.header = "
-Puppet resource types are usually backed by multiple implementations called `providers`,
-which handle variance between platforms and tools.
-
-Different providers are suitable or unsuitable on different platforms based on things
-like the presence of a given tool.
-
-Here are all of the provider-backed types and their different providers.  Any unmentioned
-types do not use providers yet.
-
-"