bolt 0.19.1 → 0.20.0

data/vendored/puppet/lib/puppet/util/metaid.rb

@@ -1,21 +0,0 @@
-class Object
-  # The hidden singleton lurks behind everyone
-  def singleton_class; class << self; self; end; end
-  def meta_eval(&blk); singleton_class.instance_eval(&blk); end
-
-  # Adds methods to a singleton_class
-  def meta_def(name, &blk)
-    meta_eval { define_method name, &blk }
-  end
-
-  # Remove singleton_class methods.
-  def meta_undef(name, &blk)
-    meta_eval { remove_method name }
-  end
-
-  # Defines an instance method within a class
-  def class_def(name, &blk)
-    class_eval { define_method name, &blk }
-  end
-end
-

data/vendored/puppet/lib/puppet/util/methodhelper.rb

@@ -1,32 +0,0 @@
-# Where we store helper methods related to, um, methods.
-module Puppet::Util::MethodHelper
-  def requiredopts(*names)
-    names.each do |name|
-      devfail("#{name} is a required option for #{self.class}") if self.send(name).nil?
-    end
-  end
-
-  # Iterate over a hash, treating each member as an attribute.
-  def set_options(options)
-    options.each do |param,value|
-      method = param.to_s + "="
-      if respond_to? method
-        self.send(method, value)
-      else
-        raise ArgumentError, _("Invalid parameter %{parameter} to object class %{class_name}") % { parameter: param, class_name: self.class }
-      end
-    end
-  end
-
-  # Take a hash and convert all of the keys to symbols if possible.
-  def symbolize_options(options)
-    options.inject({}) do |hash, opts|
-      if opts[0].respond_to? :intern
-        hash[opts[0].intern] = opts[1]
-      else
-        hash[opts[0]] = opts[1]
-      end
-      hash
-    end
-  end
-end

data/vendored/puppet/lib/puppet/util/metric.rb

@@ -1,64 +0,0 @@
-# included so we can test object types
-require 'puppet'
-require 'puppet/network/format_support'
-
-# A class for handling metrics.  This is currently ridiculously hackish.
-class Puppet::Util::Metric
-  include Puppet::Util::PsychSupport
-  include Puppet::Network::FormatSupport
-
-  attr_accessor :type, :name, :value, :label
-  attr_writer :values
-
-  def self.from_data_hash(data)
-    metric = allocate
-    metric.initialize_from_hash(data)
-    metric
-  end
-
-  def initialize_from_hash(data)
-    @name = data['name']
-    @label = data['label'] || self.class.labelize(@name)
-    @values = data['values']
-  end
-
-  def to_data_hash
-    {
-      'name' => @name,
-      'label' => @label,
-      'values' => @values
-    }
-  end
-
-  # Return a specific value
-  def [](name)
-    if value = @values.find { |v| v[0] == name }
-      return value[2]
-    else
-      return 0
-    end
-  end
-
-  def initialize(name,label = nil)
-    @name = name.to_s
-
-    @label = label || self.class.labelize(name)
-
-    @values = []
-  end
-
-  def newvalue(name,value,label = nil)
-    raise ArgumentError.new("metric name #{name.inspect} is not a string") unless name.is_a? String
-    label ||= self.class.labelize(name)
-    @values.push [name,label,value]
-  end
-
-  def values
-    @values.sort { |a, b| a[1] <=> b[1] }
-  end
-
-  # Convert a name into a label.
-  def self.labelize(name)
-    name.to_s.capitalize.gsub("_", " ")
-  end
-end

data/vendored/puppet/lib/puppet/util/monkey_patches.rb

@@ -1,108 +0,0 @@
-module Puppet::Util::MonkeyPatches
-end
-
-begin
-  Process.maxgroups = 1024
-rescue NotImplementedError
-  # Actually, I just want to ignore it, since various platforms - JRuby,
-  # Windows, and so forth - don't support it, but only because it isn't a
-  # meaningful or implementable concept there.
-end
-
-module RDoc
-  def self.caller(skip=nil)
-    in_gem_wrapper = false
-    Kernel.caller.reject { |call|
-      in_gem_wrapper ||= call =~ /#{Regexp.escape $0}:\d+:in `load'/
-    }
-  end
-end
-
-class Object
-  # ActiveSupport 2.3.x mixes in a dangerous method
-  # that can cause rspec to fork bomb
-  # and other strange things like that.
-  def daemonize
-    raise NotImplementedError, "Kernel.daemonize is too dangerous, please don't try to use it."
-  end
-end
-
-# (#19151) Reject all SSLv2 ciphers and handshakes
-require 'openssl'
-class OpenSSL::SSL::SSLContext
-  if DEFAULT_PARAMS[:options]
-    DEFAULT_PARAMS[:options] |= OpenSSL::SSL::OP_NO_SSLv2 | OpenSSL::SSL::OP_NO_SSLv3
-  else
-    DEFAULT_PARAMS[:options] = OpenSSL::SSL::OP_NO_SSLv2 | OpenSSL::SSL::OP_NO_SSLv3
-  end
-  if DEFAULT_PARAMS[:ciphers]
-    DEFAULT_PARAMS[:ciphers] << ':!SSLv2'
-  end
-
-  alias __original_initialize initialize
-  private :__original_initialize
-
-  def initialize(*args)
-    __original_initialize(*args)
-    params = {
-      :options => DEFAULT_PARAMS[:options],
-      :ciphers => DEFAULT_PARAMS[:ciphers],
-    }
-    set_params(params)
-  end
-end
-
-require 'puppet/util/platform'
-if Puppet::Util::Platform.windows?
-  require 'puppet/util/windows'
-  require 'openssl'
-
-  class OpenSSL::X509::Store
-    @puppet_certs_loaded = false
-    alias __original_set_default_paths set_default_paths
-    def set_default_paths
-      # This can be removed once openssl integrates with windows
-      # cert store, see https://rt.openssl.org/Ticket/Display.html?id=2158
-      unless @puppet_certs_loaded
-        @puppet_certs_loaded = true
-
-        Puppet::Util::Windows::RootCerts.instance.to_a.uniq { |cert| cert.to_der }.each do |x509|
-          begin
-            add_cert(x509)
-          rescue OpenSSL::X509::StoreError
-            warn "Failed to add #{x509.subject.to_s}"
-          end
-        end
-      end
-
-      __original_set_default_paths
-    end
-  end
-end
-
-# The Enumerable#uniq method was added in Ruby 2.4.0 (https://bugs.ruby-lang.org/issues/11090)
-# This is a backport to earlier Ruby versions.
-#
-unless Enumerable.instance_methods.include?(:uniq)
-  module Enumerable
-    def uniq
-      result = []
-      uniq_map = {}
-      if block_given?
-        each do |value|
-          key = yield value
-          next if uniq_map.has_key?(key)
-          uniq_map[key] = true
-          result << value
-        end
-      else
-        each do |value|
-          next if uniq_map.has_key?(value)
-          uniq_map[value] = true
-          result << value
-        end
-      end
-      result
-    end
-  end
-end

data/vendored/puppet/lib/puppet/util/multi_match.rb

@@ -1,51 +0,0 @@
-# MultiMatch allows multiple values to be tested at once in a case expression.
-# This class is needed since Array does not implement the === operator to mean
-# "each v === other.each v". 
-#
-# This class is useful in situations when the Puppet Type System cannot be used
-# (e.g. in Logging, since it needs to be able to log very early in the initialization
-# cycle of puppet)
-#
-# Typically used with the constants
-# NOT_NIL
-# TUPLE
-# TRIPLE
-# 
-# which test against single NOT_NIL value, Array with two NOT_NIL, and Array with three NOT_NIL
-#
-module Puppet::Util
-class MultiMatch
-  attr_reader :values
-
-  def initialize(*values)
-    @values = values
-  end
-
-  def ===(other)
-    lv = @values  # local var is faster than instance var
-    case other
-    when MultiMatch
-      return false unless other.values.size == values.size
-      other.values.each_with_index {|v, i| return false unless lv[i] === v || v === lv[i]}
-    when Array
-      return false unless other.size == values.size
-      other.each_with_index {|v, i| return false unless lv[i] === v || v === lv[i]}
-    else
-      false
-    end
-    true
-  end
-
-  # Matches any value that is not nil using the === operator.
-  #
-  class MatchNotNil
-    def ===(v)
-      !v.nil?
-    end
-  end
-
-  NOT_NIL = MatchNotNil.new().freeze
-  TUPLE = MultiMatch.new(NOT_NIL, NOT_NIL).freeze
-  TRIPLE = MultiMatch.new(NOT_NIL, NOT_NIL, NOT_NIL).freeze
-end
-end

data/vendored/puppet/lib/puppet/util/nagios_maker.rb

@@ -1,85 +0,0 @@
-require 'puppet/external/nagios'
-require 'puppet/external/nagios/base'
-require 'puppet/provider/naginator'
-
-module Puppet::Util::NagiosMaker
-  # Create a new nagios type, using all of the parameters
-  # from the parser.
-  def self.create_nagios_type(name)
-    name = name.to_sym
-    full_name = ("nagios_#{name}").to_sym
-
-    raise Puppet::DevError, _("No nagios type for %{name}") % { name: name } unless nagtype = Nagios::Base.type(name)
-
-    type = Puppet::Type.newtype(full_name) do
-
-      # Generate a file resource if necessary.
-      #
-      # @see Puppet::Type::File and its properties owner, group and mode.
-      def generate
-        return nil unless self[:owner] or self[:group] or self[:mode]
-        props = { :name => self[:target] }
-        [ :owner, :group, :mode ].each do |prop|
-          props[prop] = self[prop] if self[prop]
-        end
-        Puppet::Type.type(:file).new(props)
-      end
-
-    end
-
-    type.ensurable
-
-    type.newparam(nagtype.namevar, :namevar => true) do
-      desc "The name of this nagios_#{nagtype.name} resource."
-    end
-
-    [ :owner, :group, :mode].each do |fileprop|
-      type.newparam(fileprop) do
-        desc "The desired #{fileprop} of the config file for this nagios_#{nagtype.name} resource.
- 
-          NOTE: If the target file is explicitly managed by a file resource in your manifest,
-          this parameter has no effect. If a parent directory of the target is managed by
-          a recursive file resource, this limitation does not apply (i.e., this parameter
-          takes precedence, and if purge is used, the target file is exempt)."
-      end
-    end
-
-    # We deduplicate the parameters because it makes sense to allow Naginator to have dupes.
-    nagtype.parameters.uniq.each do |param|
-      next if param == nagtype.namevar
-
-      # We can't turn these parameter names into constants, so at least for now they aren't
-      # supported.
-      next if param.to_s =~ /^[0-9]/
-
-      type.newproperty(param) do
-        desc "Nagios configuration file parameter."
-      end
-    end
-
-    type.newproperty(:target) do
-      desc 'The target.'
-
-      defaultto do
-        resource.class.defaultprovider.default_target
-      end
-    end
-
-    target = "/etc/nagios/#{full_name.to_s}.cfg"
-    provider = type.provide(:naginator, :parent => Puppet::Provider::Naginator, :default_target => target) {}
-    provider.nagios_type
-
-    type.desc "The Nagios type #{name.to_s}.  This resource type is autogenerated using the
-      model developed in Naginator, and all of the Nagios types are generated using the
-      same code and the same library.
-
-      This type generates Nagios configuration statements in Nagios-parseable configuration
-      files.  By default, the statements will be added to `#{target}`, but
-      you can send them to a different file by setting their `target` attribute.
-
-      You can purge Nagios resources using the `resources` type, but *only*
-      in the default file locations.  This is an architectural limitation.
-
-    "
-  end
-end

data/vendored/puppet/lib/puppet/util/network_device.rb

@@ -1,17 +0,0 @@
-class Puppet::Util::NetworkDevice
-  class << self
-    attr_reader :current
-  end
-
-  def self.init(device)
-    require "puppet/util/network_device/#{device.provider}/device"
-    @current = Puppet::Util::NetworkDevice.const_get(device.provider.capitalize).const_get(:Device).new(device.url, device.options)
-  rescue => detail
-    raise detail, _("Can't load %{provider} for %{device}: %{detail}") % { provider: device.provider, device: device.name, detail: detail }, detail.backtrace
-  end
-
-  # Should only be used in tests
-  def self.teardown
-    @current = nil
-  end
-end

data/vendored/puppet/lib/puppet/util/network_device/base.rb

@@ -1,23 +0,0 @@
-require 'puppet/util/autoload'
-require 'uri'
-require 'puppet/util/network_device/transport'
-require 'puppet/util/network_device/transport/base'
-
-class Puppet::Util::NetworkDevice::Base
-
-  attr_accessor :url, :transport
-
-  def initialize(url, options = {})
-    @url = URI.parse(url)
-
-    @autoloader = Puppet::Util::Autoload.new(self, "puppet/util/network_device/transport")
-
-    if @autoloader.load(@url.scheme)
-      @transport = Puppet::Util::NetworkDevice::Transport.const_get(@url.scheme.capitalize).new(options[:debug])
-      @transport.host = @url.host
-      @transport.port = @url.port || case @url.scheme ; when "ssh" ; 22 ; when "telnet" ; 23 ; end
-      @transport.user = @url.user
-      @transport.password = @url.password
-    end
-  end
-end

data/vendored/puppet/lib/puppet/util/network_device/cisco.rb

@@ -1,4 +0,0 @@
-
-module Puppet::Util::NetworkDevice::Cisco
-
-end

data/vendored/puppet/lib/puppet/util/network_device/cisco/device.rb

@@ -1,285 +0,0 @@
-require 'puppet'
-require 'puppet/util'
-require 'puppet/util/network_device/base'
-require 'puppet/util/network_device/ipcalc'
-require 'puppet/util/network_device/cisco/interface'
-require 'puppet/util/network_device/cisco/facts'
-require 'ipaddr'
-
-class Puppet::Util::NetworkDevice::Cisco::Device < Puppet::Util::NetworkDevice::Base
-
-  include Puppet::Util::NetworkDevice::IPCalc
-
-  attr_accessor :enable_password
-
-  def initialize(url, options = {})
-    super(url, options)
-    @enable_password = options[:enable_password] || parse_enable(@url.query)
-    transport.default_prompt = /[#>]\s?\z/n
-  end
-
-  def parse_enable(query)
-    if query
-      params = CGI.parse(query)
-      params['enable'].first unless params['enable'].empty?
-    end
-  end
-
-  def connect
-    transport.connect
-    login
-    transport.command("terminal length 0") do |out|
-      enable if out =~ />\s?\z/n
-    end
-    find_capabilities
-  end
-
-  def disconnect
-    transport.close
-  end
-
-  def command(cmd = nil)
-    connect
-    out = execute(cmd) if cmd
-    yield self if block_given?
-    disconnect
-    out
-  end
-
-  def execute(cmd)
-    transport.command(cmd) do |out|
-      if out =~ /^%/mo or out =~ /^Command rejected:/mo
-        # strip off the command just sent
-        error = out.sub(cmd,'')
-        Puppet.err _("Error while executing '%{cmd}', device returned: %{error}") % { cmd: cmd, error: error }
-      end
-    end
-  end
-
-  def login
-    return if transport.handles_login?
-    if @url.user != ''
-      transport.command(@url.user, :prompt => /^Password:/)
-    else
-      transport.expect(/^Password:/)
-    end
-    transport.command(@url.password)
-  end
-
-  def enable
-    raise _("Can't issue \"enable\" to enter privileged, no enable password set") unless enable_password
-    transport.command("enable", :prompt => /^Password:/)
-    transport.command(enable_password)
-  end
-
-  def support_vlan_brief?
-    !! @support_vlan_brief
-  end
-
-  def find_capabilities
-    out = execute("sh vlan brief")
-    lines = out.split("\n")
-    lines.shift; lines.pop
-
-    @support_vlan_brief = ! (lines.first =~ /^%/)
-  end
-
-  IF = {
-    :FastEthernet => %w{FastEthernet FastEth Fast FE Fa F},
-    :GigabitEthernet => %w{GigabitEthernet GigEthernet GigEth GE Gi G},
-    :TenGigabitEthernet => %w{TenGigabitEthernet TE Te},
-    :Ethernet => %w{Ethernet Eth E},
-    :Serial => %w{Serial Se S},
-    :PortChannel => %w{PortChannel Port-Channel Po},
-    :POS => %w{POS P},
-    :VLAN => %w{VLAN VL V},
-    :Loopback => %w{Loopback Loop Lo},
-    :ATM => %w{ATM AT A},
-    :Dialer => %w{Dialer Dial Di D},
-    :VirtualAccess => %w{Virtual-Access Virtual-A Virtual Virt}
-  }
-
-  def canonicalize_ifname(interface)
-    IF.each do |k,ifnames|
-      if found = ifnames.find { |ifname| interface =~ /^#{ifname}\s*\d/i }
-        found = /^#{found}(.+)\Z/i.match(interface)
-        return "#{k.to_s}#{found[1]}".gsub(/\s+/,'')
-      end
-    end
-    interface
-  end
-
-  def facts
-    @facts ||= Puppet::Util::NetworkDevice::Cisco::Facts.new(transport)
-    facts = {}
-    command do |ng|
-      facts = @facts.retrieve
-    end
-    facts
-  end
-
-  def interface(name)
-    ifname = canonicalize_ifname(name)
-    interface = parse_interface(ifname)
-    return { :ensure => :absent } if interface.empty?
-    interface.merge!(parse_trunking(ifname))
-    interface.merge!(parse_interface_config(ifname))
-  end
-
-  def new_interface(name)
-    Puppet::Util::NetworkDevice::Cisco::Interface.new(canonicalize_ifname(name), transport)
-  end
-
-  def parse_interface(name)
-    resource = {}
-    out = execute("sh interface #{name}")
-    lines = out.split("\n")
-    lines.shift; lines.pop
-    lines.each do |l|
-      if l =~ /#{name} is (.+), line protocol is /
-        resource[:ensure] = ($1 == 'up' ? :present : :absent);
-      end
-      if l =~ /Auto Speed \(.+\),/ or l =~ /Auto Speed ,/ or l =~ /Auto-speed/
-        resource[:speed] = :auto
-      end
-      if l =~ /, (.+)Mb\/s/
-        resource[:speed] = $1
-      end
-      if l =~ /\s+Auto-duplex \((.{4})\),/
-        resource[:duplex] = :auto
-      end
-      if l =~ /\s+(.+)-duplex/
-        resource[:duplex] = $1 == "Auto" ? :auto : $1.downcase.to_sym
-      end
-      if l =~ /Description: (.+)/
-        resource[:description] = $1
-      end
-    end
-    resource
-  end
-
-  def parse_interface_config(name)
-    resource = Hash.new { |hash, key| hash[key] = Array.new ; }
-    out = execute("sh running-config interface #{name} | begin interface")
-    lines = out.split("\n")
-    lines.shift; lines.pop
-    lines.each do |l|
-      if l =~ /ip address (#{IP}) (#{IP})\s+secondary\s*$/
-        resource[:ipaddress] << [prefix_length(IPAddr.new($2)), IPAddr.new($1), 'secondary']
-      end
-      if l =~ /ip address (#{IP}) (#{IP})\s*$/
-        resource[:ipaddress] << [prefix_length(IPAddr.new($2)), IPAddr.new($1), nil]
-      end
-      if l =~ /ipv6 address (#{IP})\/(\d+) (eui-64|link-local)/
-        resource[:ipaddress] << [$2.to_i, IPAddr.new($1), $3]
-      end
-      if l =~ /channel-group\s+(\d+)/
-        resource[:etherchannel] = $1
-      end
-    end
-    resource
-  end
-
-  def parse_vlans
-    vlans = {}
-    out = execute(support_vlan_brief? ? "sh vlan brief" : "sh vlan-switch brief")
-    lines = out.split("\n")
-    lines.shift; lines.shift; lines.shift; lines.pop
-    vlan = nil
-    lines.each do |l|
-      case l
-            # vlan    name    status
-      when /^(\d+)\s+(\w+)\s+(\w+)\s+([a-zA-Z0-9,\/. ]+)\s*$/
-        vlan = { :name => $1, :description => $2, :status => $3, :interfaces => [] }
-        if $4.strip.length > 0
-          vlan[:interfaces] = $4.strip.split(/\s*,\s*/).map{ |ifn| canonicalize_ifname(ifn) }
-        end
-        vlans[vlan[:name]] = vlan
-      when /^\s+([a-zA-Z0-9,\/. ]+)\s*$/
-        raise _("invalid sh vlan summary output") unless vlan
-        if $1.strip.length > 0
-          vlan[:interfaces] += $1.strip.split(/\s*,\s*/).map{ |ifn| canonicalize_ifname(ifn) }
-        end
-      else
-      end
-    end
-    vlans
-  end
-
-  def update_vlan(id, is = {}, should = {})
-    if should[:ensure] == :absent
-      Puppet.info _("Removing %{id} from device vlan") % { id: id }
-      execute("conf t")
-      execute("no vlan #{id}")
-      execute("exit")
-      return
-    end
-
-    # Cisco VLANs are supposed to be alphanumeric only
-    if should[:description] =~ /[^\w]/
-      Puppet.err _("Invalid VLAN name '%{name}' for Cisco device.\nVLAN name must be alphanumeric, no spaces or special characters.") % { name: should[:description] }
-      return
-    end
-    
-    # We're creating or updating an entry
-    execute("conf t")
-    execute("vlan #{id}")
-    [is.keys, should.keys].flatten.uniq.each do |property|
-      Puppet.debug("trying property: #{property}: #{should[property]}")
-      next if property != :description
-      execute("name #{should[property]}")
-    end
-    execute("exit")
-    execute("exit")
-  end
-
-  def parse_trunking(interface)
-    trunking = {}
-    out = execute("sh interface #{interface} switchport")
-    lines = out.split("\n")
-    lines.shift; lines.pop
-    lines.each do |l|
-      case l
-      when /^Administrative mode:\s+(.*)$/i
-        case $1
-        when "trunk"
-          trunking[:mode] = :trunk
-        when "static access"
-          trunking[:mode] = :access
-        when "dynamic auto"
-          trunking[:mode] = 'dynamic auto'
-        when "dynamic desirable"
-          trunking[:mode] = 'dynamic desirable'
-        else
-          raise _("Unknown switchport mode: %{mode} for %{interface}") % { mode: $1, interface: interface }
-        end
-      when /^Administrative Trunking Encapsulation:\s+(.*)$/
-        case $1
-        when "dot1q","isl"
-          trunking[:encapsulation] = $1.to_sym if trunking[:mode] != :access
-        when "negotiate"
-          trunking[:encapsulation] = :negotiate
-        else
-          raise _("Unknown switchport encapsulation: %{value} for %{interface}") % { value: $1, interface: interface }
-        end
-      when /^Access Mode VLAN:\s+(.*) \((.*)\)$/
-        trunking[:access_vlan] = $1 if $2 != '(Inactive)'
-      when /^Trunking Native Mode VLAN:\s+(.*) \(.*\)$/
-        trunking[:native_vlan] = $1
-      when /^Trunking VLANs Enabled:\s+(.*)$/
-        next if trunking[:mode] == :access
-        vlans = $1
-        trunking[:allowed_trunk_vlans] = case vlans
-        when /all/i
-          :all
-        when /none/i
-          :none
-        else
-          vlans
-        end
-      end
-    end
-    trunking
-  end
-
-end