bolt 0.24.0 → 0.25.0

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

@@ -1,225 +0,0 @@
-# @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

@@ -1,8 +0,0 @@
-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

@@ -1,42 +0,0 @@
-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

@@ -1,20 +0,0 @@
-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

@@ -1,9 +0,0 @@
-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

@@ -1,17 +0,0 @@
-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

@@ -1,14 +0,0 @@
-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

@@ -1,51 +0,0 @@
-# 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

@@ -1,15 +0,0 @@
-# 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

@@ -1,12 +0,0 @@
-# Just to make the constants work out.
-require 'puppet'
-require 'openssl'
-
-module Puppet::SSL # :nodoc:
-  CA_NAME = "ca"
-  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

@@ -1,150 +0,0 @@
-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
-
-  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::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::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::Host (.indirection.find)
-    # Puppet::SSL::Inventory (.indirection.search, implements its own add / rebuild / serials with encoding UTF8)
-    # 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