bolt 0.20.0 → 0.20.2

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

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

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

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

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

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

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

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

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

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

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

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