bolt 0.20.0 → 0.20.2

data/vendored/puppet/lib/puppet/settings/ini_file.rb

@@ -0,0 +1,225 @@
+# @api private
+class Puppet::Settings::IniFile
+  DEFAULT_SECTION_NAME = "main"
+
+  def self.update(config_fh, &block)
+    config = parse(config_fh)
+    manipulator = Manipulator.new(config)
+    yield manipulator
+    config.write(config_fh)
+  end
+
+  def self.parse(config_fh)
+    config = new([DefaultSection.new])
+    config_fh.each_line do |line|
+      case line.chomp
+      when /^(\s*)\[([[:word:]]+)\](\s*)$/
+        config.append(SectionLine.new($1, $2, $3))
+      when /^(\s*)([[:word:]]+)(\s*=\s*)(.*?)(\s*)$/
+        config.append(SettingLine.new($1, $2, $3, $4, $5))
+      else
+        config.append(Line.new(line))
+      end
+    end
+
+    config
+  end
+
+  def initialize(lines = [])
+    @lines = lines
+  end
+
+  def append(line)
+    line.previous = @lines.last
+    @lines << line
+  end
+
+  def delete(section, name)
+    delete_offset = @lines.index(setting(section, name))
+    next_offset = delete_offset + 1
+    if next_offset < @lines.length
+      @lines[next_offset].previous = @lines[delete_offset].previous
+    end
+    @lines.delete_at(delete_offset)
+  end
+
+  def insert_after(line, new_line)
+    new_line.previous = line
+
+    insertion_point = @lines.index(line)
+    @lines.insert(insertion_point + 1, new_line)
+    if @lines.length > insertion_point + 2
+      @lines[insertion_point + 2].previous = new_line
+    end
+  end
+
+  def section_lines
+    @lines.select { |line| line.is_a?(SectionLine) }
+  end
+
+  def section_line(name)
+    section_lines.find { |section| section.name == name }
+  end
+
+  def setting(section, name)
+    settings_in(lines_in(section)).find do |line|
+      line.name == name
+    end
+  end
+
+  def lines_in(section_name)
+    section_lines = []
+    current_section_name = DEFAULT_SECTION_NAME
+    @lines.each do |line|
+      if line.is_a?(SectionLine)
+        current_section_name = line.name
+      elsif current_section_name == section_name
+        section_lines << line
+      end
+    end
+
+    section_lines
+  end
+
+  def settings_in(lines)
+    lines.select { |line| line.is_a?(SettingLine) }
+  end
+
+  def settings_exist_in_default_section?
+    lines_in(DEFAULT_SECTION_NAME).any? { |line| line.is_a?(SettingLine) }
+  end
+
+  def section_exists_with_default_section_name?
+    section_lines.any? do |section|
+      !section.is_a?(DefaultSection) && section.name == DEFAULT_SECTION_NAME
+    end
+  end
+
+  def set_default_section_write_sectionline(value)
+    if index = @lines.find_index { |line| line.is_a?(DefaultSection) }
+      @lines[index].write_sectionline = true
+    end
+  end
+
+  def write(fh)
+    # If no real section line for the default section exists, configure the
+    # DefaultSection object to write its section line. (DefaultSection objects
+    # don't write the section line unless explicitly configured to do so)
+    if settings_exist_in_default_section? && !section_exists_with_default_section_name?
+      set_default_section_write_sectionline(true)
+    end
+
+    fh.truncate(0)
+    fh.rewind
+    @lines.each do |line|
+      line.write(fh)
+    end
+    fh.flush
+  end
+
+  class Manipulator
+    def initialize(config)
+      @config = config
+    end
+
+    def set(section, name, value)
+      setting = @config.setting(section, name)
+      if setting
+        setting.value = value
+      else
+        add_setting(section, name, value)
+      end
+    end
+
+    def delete(section_name, name)
+      setting = @config.setting(section_name, name)
+      if setting
+        @config.delete(section_name, name)
+        setting.to_s.chomp
+      end
+    end
+
+    private
+
+    def add_setting(section_name, name, value)
+      section = @config.section_line(section_name)
+      if section.nil?
+        previous_line = SectionLine.new("", section_name, "")
+        @config.append(previous_line)
+      else
+        previous_line = @config.settings_in(@config.lines_in(section_name)).last || section
+      end
+
+      @config.insert_after(previous_line, SettingLine.new("", name, " = ", value, ""))
+    end
+  end
+
+  module LineNumber
+    attr_accessor :previous
+
+    def line_number
+      line = 0
+      previous_line = previous
+      while previous_line
+        line += 1
+        previous_line = previous_line.previous
+      end
+      line
+    end
+  end
+
+  Line = Struct.new(:text) do
+    include LineNumber
+
+    def to_s
+      text
+    end
+
+    def write(fh)
+      fh.puts(to_s)
+    end
+  end
+
+  SettingLine = Struct.new(:prefix, :name, :infix, :value, :suffix) do
+    include LineNumber
+
+    def to_s
+      "#{prefix}#{name}#{infix}#{value}#{suffix}"
+    end
+
+    def write(fh)
+      fh.puts(to_s)
+    end
+
+    def ==(other)
+      super(other) && self.line_number == other.line_number
+    end
+  end
+
+  SectionLine = Struct.new(:prefix, :name, :suffix) do
+    include LineNumber
+
+    def to_s
+      "#{prefix}[#{name}]#{suffix}"
+    end
+
+    def write(fh)
+      fh.puts(to_s)
+    end
+  end
+
+  class DefaultSection < SectionLine
+    attr_accessor :write_sectionline
+
+    def initialize
+      @write_sectionline = false
+      super("", DEFAULT_SECTION_NAME, "")
+    end
+
+    def write(fh)
+      if @write_sectionline
+        super(fh)
+      end
+    end
+  end
+end

data/vendored/puppet/lib/puppet/settings/path_setting.rb

@@ -0,0 +1,8 @@
+class Puppet::Settings::PathSetting < Puppet::Settings::StringSetting
+  def munge(value)
+    if value.is_a?(String)
+      value = value.split(File::PATH_SEPARATOR).map { |d| File.expand_path(d) }.join(File::PATH_SEPARATOR)
+    end
+    value
+  end
+end

data/vendored/puppet/lib/puppet/settings/priority_setting.rb

@@ -0,0 +1,42 @@
+require 'puppet/settings/base_setting'
+
+# A setting that represents a scheduling priority, and evaluates to an
+# OS-specific priority level.
+class Puppet::Settings::PrioritySetting < Puppet::Settings::BaseSetting
+  PRIORITY_MAP =
+    if Puppet::Util::Platform.windows?
+      require 'puppet/util/windows/process'
+      {
+        :high    => Puppet::Util::Windows::Process::HIGH_PRIORITY_CLASS,
+        :normal  => Puppet::Util::Windows::Process::NORMAL_PRIORITY_CLASS,
+        :low     => Puppet::Util::Windows::Process::BELOW_NORMAL_PRIORITY_CLASS,
+        :idle    => Puppet::Util::Windows::Process::IDLE_PRIORITY_CLASS
+      }
+    else
+      {
+        :high    => -10,
+        :normal  => 0,
+        :low     => 10,
+        :idle    => 19
+      }
+    end
+
+  def type
+    :priority
+  end
+
+  def munge(value)
+    return unless value
+
+    case
+    when value.is_a?(Integer)
+      value
+    when (value.is_a?(String) and value =~ /\d+/)
+      value.to_i
+    when (value.is_a?(String) and PRIORITY_MAP[value.to_sym])
+      PRIORITY_MAP[value.to_sym]
+    else
+      raise Puppet::Settings::ValidationError, _("Invalid priority format '%{value}' for parameter: %{name}") % { value: value.inspect, name: @name }
+    end
+  end
+end

data/vendored/puppet/lib/puppet/settings/server_list_setting.rb

@@ -0,0 +1,20 @@
+class Puppet::Settings::ServerListSetting < Puppet::Settings::ArraySetting
+
+  def type
+    :server_list
+  end
+
+  def munge(value)
+    servers = super 
+    servers.map! { |server| 
+      case server
+      when String
+        server.split(':')
+      when Array
+        server
+      else
+        raise ArgumentError, _("Expected an Array of String, got a %{klass}") % { klass: value.class }
+      end
+    }
+  end
+end

data/vendored/puppet/lib/puppet/settings/string_setting.rb

@@ -0,0 +1,9 @@
+class Puppet::Settings::StringSetting < Puppet::Settings::BaseSetting
+  def type
+    :string
+  end
+
+  def validate(value)
+    value.nil? or value.is_a?(String)
+  end
+end

data/vendored/puppet/lib/puppet/settings/symbolic_enum_setting.rb

@@ -0,0 +1,17 @@
+class Puppet::Settings::SymbolicEnumSetting < Puppet::Settings::BaseSetting
+  attr_accessor :values
+
+  def type
+    :symbolic_enum
+  end
+
+  def munge(value)
+    sym = value.to_sym
+    if values.include?(sym)
+      sym
+    else
+      raise Puppet::Settings::ValidationError,
+        _("Invalid value '%{value}' for parameter %{name}. Allowed values are '%{allowed_values}'") % { value: value, name: @name, allowed_values: values.join("', '") }
+    end
+  end
+end

data/vendored/puppet/lib/puppet/settings/terminus_setting.rb

@@ -0,0 +1,14 @@
+class Puppet::Settings::TerminusSetting < Puppet::Settings::BaseSetting
+  def munge(value)
+    case value
+    when '', nil
+      nil
+    when String
+      value.intern
+    when Symbol
+      value
+    else
+      raise Puppet::Settings::ValidationError, _("Invalid terminus setting: %{value}") % { value: value }
+    end
+  end
+end

data/vendored/puppet/lib/puppet/settings/ttl_setting.rb

@@ -0,0 +1,51 @@
+# A setting that represents a span of time to live, and evaluates to Numeric
+# seconds to live where 0 means shortest possible time to live, a positive numeric value means time
+# to live in seconds, and the symbolic entry 'unlimited' is an infinite amount of time.
+#
+class Puppet::Settings::TTLSetting < Puppet::Settings::BaseSetting
+  # How we convert from various units to seconds.
+  UNITMAP = {
+    # 365 days isn't technically a year, but is sufficient for most purposes
+    "y" => 365 * 24 * 60 * 60,
+    "d" => 24 * 60 * 60,
+    "h" => 60 * 60,
+    "m" => 60,
+    "s" => 1
+  }
+
+  # A regex describing valid formats with groups for capturing the value and units
+  FORMAT = /^(\d+)(y|d|h|m|s)?$/
+
+  def type
+    :ttl
+  end
+
+  # Convert the value to Numeric, parsing numeric string with units if necessary.
+  def munge(value)
+    self.class.munge(value, @name)
+  end
+
+  def print(value)
+    val = munge(value)
+    val == Float::INFINITY ? 'unlimited' : val
+  end
+
+  # Convert the value to Numeric, parsing numeric string with units if necessary.
+  def self.munge(value, param_name)
+    case
+    when value.is_a?(Numeric)
+      if value < 0
+        raise Puppet::Settings::ValidationError, _("Invalid negative 'time to live' %{value} - did you mean 'unlimited'?") % { value: value.inspect }
+      end
+      value
+
+    when value == 'unlimited'
+      Float::INFINITY
+
+    when (value.is_a?(String) and value =~ FORMAT)
+      $1.to_i * UNITMAP[$2 || 's']
+    else
+      raise Puppet::Settings::ValidationError, _("Invalid 'time to live' format '%{value}' for parameter: %{param_name}") % { value: value.inspect, param_name: param_name }
+    end
+  end
+end

data/vendored/puppet/lib/puppet/settings/value_translator.rb

@@ -0,0 +1,15 @@
+# Convert arguments into booleans, integers, or whatever.
+class Puppet::Settings::ValueTranslator
+  def [](value)
+    # Handle different data types correctly
+    return case value
+      when /^false$/i; false
+      when /^true$/i; true
+      when /^\d+$/i; Integer(value)
+      when true; true
+      when false; false
+      else
+        value.gsub(/^["']|["']$/,'').sub(/\s+$/, '')
+    end
+  end
+end

data/vendored/puppet/lib/puppet/ssl.rb

@@ -0,0 +1,13 @@
+# Just to make the constants work out.
+require 'puppet'
+require 'openssl'
+
+module Puppet::SSL # :nodoc:
+  CA_NAME = "ca"
+  require 'puppet/ssl/configuration'
+  require 'puppet/ssl/host'
+  require 'puppet/ssl/oids'
+  require 'puppet/ssl/validator'
+  require 'puppet/ssl/validator/no_validator'
+  require 'puppet/ssl/validator/default_validator'
+end

data/vendored/puppet/lib/puppet/ssl/base.rb

@@ -0,0 +1,158 @@
+require 'openssl'
+require 'puppet/ssl'
+require 'puppet/ssl/digest'
+require 'puppet/util/ssl'
+
+# The base class for wrapping SSL instances.
+class Puppet::SSL::Base
+  # For now, use the YAML separator.
+  SEPARATOR = "\n---\n"
+
+  # Only allow printing ascii characters, excluding /
+  VALID_CERTNAME = /\A[ -.0-~]+\Z/
+
+  def self.from_multiple_s(text)
+    text.split(SEPARATOR).collect { |inst| from_s(inst) }
+  end
+
+  def self.to_multiple_s(instances)
+    instances.collect { |inst| inst.to_s }.join(SEPARATOR)
+  end
+
+  def self.wraps(klass)
+    @wrapped_class = klass
+  end
+
+  def self.wrapped_class
+    raise(Puppet::DevError, _("%{name} has not declared what class it wraps") % { name: self }) unless defined?(@wrapped_class)
+    @wrapped_class
+  end
+
+  def self.validate_certname(name)
+    raise _("Certname %{name} must not contain unprintable or non-ASCII characters") % { name: name.inspect } unless name =~ VALID_CERTNAME
+  end
+
+  attr_accessor :name, :content
+
+  # Is this file for the CA?
+  def ca?
+    name == Puppet::SSL::Host.ca_name
+  end
+
+  def generate
+    raise Puppet::DevError, _("%{class_name} did not override 'generate'") % { class_name: self.class }
+  end
+
+  def initialize(name)
+    @name = name.to_s.downcase
+    self.class.validate_certname(@name)
+  end
+
+  ##
+  # name_from_subject extracts the common name attribute from the subject of an
+  # x.509 certificate certificate
+  #
+  # @api private
+  #
+  # @param [OpenSSL::X509::Name] subject The full subject (distinguished name) of the x.509
+  #   certificate.
+  #
+  # @return [String] the name (CN) extracted from the subject.
+  def self.name_from_subject(subject)
+    Puppet::Util::SSL.cn_from_subject(subject)
+  end
+
+  # Create an instance of our Puppet::SSL::* class using a given instance of the wrapped class
+  def self.from_instance(instance, name = nil)
+    unless instance.is_a?(wrapped_class)
+      raise ArgumentError, _("Object must be an instance of %{class_name}, %{actual_class} given") %
+          { class_name: wrapped_class, actual_class: instance.class }
+    end
+    if name.nil? and !instance.respond_to?(:subject)
+      raise ArgumentError, _("Name must be supplied if it cannot be determined from the instance")
+    end
+
+    name ||= name_from_subject(instance.subject)
+    result = new(name)
+    result.content = instance
+    result
+  end
+
+  # Convert a string into an instance
+  def self.from_s(string, name = nil)
+    instance = wrapped_class.new(string)
+    from_instance(instance, name)
+  end
+
+  # Read content from disk appropriately.
+  def read(path)
+    # applies to Puppet::SSL::Certificate, Puppet::SSL::CertificateRequest, Puppet::SSL::CertificateRevocationList
+    # Puppet::SSL::Key uses this, but also provides its own override
+    # nothing derives from Puppet::SSL::Certificate, but it is called by a number of other SSL Indirectors:
+    # Puppet::SSL::Certificate::DisabledCa (:find, :save, :destroy)
+    # Puppet::Indirector::CertificateStatus::File (.indirection.find)
+    # Puppet::Network::HTTP::WEBrick (.indirection.find)
+    # Puppet::Network::HTTP::RackREST (.from_instance)
+    # Puppet::Network::HTTP::WEBrickREST (.from_instance)
+    # Puppet::SSL::CertificateAuthority (.new, .indirection.find, .indirection.save)
+    # Puppet::SSL::Host (.indirection.find)
+    # Puppet::SSL::Inventory (.indirection.search, implements its own add / rebuild / serials with encoding UTF8)
+    # Puppet::SSL::CertificateAuthority::Interface (.indirection.find)
+    # Puppet::SSL::Validator::DefaultValidator (.from_instance) / Puppet::SSL::Validator::NoValidator does nothing
+    @content = wrapped_class.new(Puppet::FileSystem.read(path, :encoding => Encoding::ASCII))
+  end
+
+  # Convert our thing to pem.
+  def to_s
+    return "" unless content
+    content.to_pem
+  end
+
+  def to_data_hash
+    to_s
+  end
+
+  # Provide the full text of the thing we're dealing with.
+  def to_text
+    return "" unless content
+    content.to_text
+  end
+
+  def fingerprint(md = :SHA256)
+    mds = md.to_s.upcase
+    digest(mds).to_hex
+  end
+
+  def digest(algorithm=nil)
+    unless algorithm
+      algorithm = digest_algorithm
+    end
+
+    Puppet::SSL::Digest.new(algorithm, content.to_der)
+  end
+
+  def digest_algorithm
+    # The signature_algorithm on the X509 cert is a combination of the digest
+    # algorithm and the encryption algorithm
+    # e.g. md5WithRSAEncryption, sha256WithRSAEncryption
+    # Unfortunately there isn't a consistent pattern
+    # See RFCs 3279, 5758
+    digest_re = Regexp.union(
+      /ripemd160/i,
+      /md[245]/i,
+      /sha\d*/i
+    )
+    ln = content.signature_algorithm
+    if match = digest_re.match(ln)
+      match[0].downcase
+    else
+      raise Puppet::Error, _("Unknown signature algorithm '%{ln}'") % { ln: ln }
+    end
+  end
+
+  private
+
+  def wrapped_class
+    self.class.wrapped_class
+  end
+end