puppet 2.6.18 → 2.7.1

data/lib/puppet/util/log.rb

@@ -58,6 +58,7 @@ class Puppet::Util::Log
     destinations.keys.each { |dest|
       close(dest)
     }
+    raise Puppet::DevError.new("Log.close_all failed to close #{@destinations.keys.inspect}") if !@destinations.empty?
   end
 
   # Flush any log destinations that support such operations.

data/lib/puppet/util/log/destinations.rb

@@ -96,7 +96,7 @@ Puppet::Util::Log.newdesttype :console do
   HWHITE  = {:console => "", :html => "FFFFFF"}
   RESET   = {:console => "",    :html => ""      }
 
-  @@colormap = {
+  Colormap = {
     :debug => WHITE,
     :info => GREEN,
     :notice => CYAN,
@@ -117,11 +117,11 @@ Puppet::Util::Log.newdesttype :console do
   end
 
   def console_color(level, str)
-    @@colormap[level][:console] + str + RESET[:console]
+    Colormap[level][:console] + str + RESET[:console]
   end
 
   def html_color(level, str)
-    %{<span style="color: %s">%s</span>} % [@@colormap[level][:html], str]
+    %{<span style="color: %s">%s</span>} % [Colormap[level][:html], str]
   end
 
   def initialize
@@ -205,8 +205,20 @@ Puppet::Util::Log.newdesttype :report do
 end
 
 # Log to an array, just for testing.
+module Puppet::Test
+  class LogCollector
+    def initialize(logs)
+      @logs = logs
+    end
+
+    def <<(value)
+      @logs << value
+    end
+  end
+end
+
 Puppet::Util::Log.newdesttype :array do
-  match "Array"
+  match "Puppet::Test::LogCollector"
 
   def initialize(messages)
     @messages = messages

data/lib/puppet/util/logging.rb

@@ -15,6 +15,17 @@ module Puppet::Util::Logging
     end
   end
 
+  def deprecation_warning(message)
+    $deprecation_warnings ||= Hash.new(0)
+    if $deprecation_warnings.length < 100 and ($deprecation_warnings[message] += 1) == 1
+      warning message
+    end
+  end
+
+  def clear_deprecation_warnings
+    $deprecation_warnings.clear if $deprecation_warnings
+  end
+
   private
 
   def is_resource?

data/lib/puppet/util/monkey_patches.rb

@@ -52,6 +52,13 @@ if RUBY_VERSION == '1.8.7'
 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
+
   # The following code allows callers to make assertions that are only
   # checked when the environment variable PUPPET_ENABLE_ASSERTIONS is
   # set to a non-empty string.  For example:
@@ -96,8 +103,6 @@ class Array
       ret += tmp.combination(num - 1).map{|a| a.unshift(e) }
     end
   end unless method_defined? :combination
-
-  alias :count :length unless method_defined? :count
 end
 
 
@@ -106,78 +111,3 @@ class Symbol
     Proc.new { |*args| args.shift.__send__(self, *args) }
   end unless method_defined? :to_proc
 end
-
-module Enumerable
-  # Use *args so we can distinguish no argument from nil.
-  def count(*args)
-    seq = 0
-    if !args.empty?
-      item = args[0]
-      each { |o| seq += 1 if item == o }
-    elsif block_given?
-      each { |o| seq += 1 if yield(o) }
-    else
-      each { seq += 1 }
-    end
-    seq
-  end unless method_defined? :count
-end
-
-class String
-  def lines(separator = $/)
-    lines = split(separator)
-    block_given? and lines.each {|line| yield line }
-    lines
-  end
-end
-
-class IO
-  def lines(separator = $/)
-    lines = split(separator)
-    block_given? and lines.each {|line| yield line }
-    lines
-  end
-end
-
-# (#19151) Reject all SSLv2 ciphers and handshakes
-require 'openssl'
-class OpenSSL::SSL::SSLContext
-  if match = /^1\.8\.(\d+)/.match(RUBY_VERSION)
-    older_than_187 = match[1].to_i < 7
-  else
-    older_than_187 = false
-  end
-
-  alias __original_initialize initialize
-  private :__original_initialize
-
-  if older_than_187
-    def initialize(*args)
-      __original_initialize(*args)
-      if bitmask = self.options
-        self.options = bitmask | OpenSSL::SSL::OP_NO_SSLv2
-      else
-        self.options = OpenSSL::SSL::OP_NO_SSLv2
-      end
-      # These are the default ciphers in recent MRI versions.  See
-      # https://github.com/ruby/ruby/blob/v1_9_3_392/ext/openssl/lib/openssl/ssl-internal.rb#L26
-      self.ciphers = "ALL:!ADH:!EXPORT:!SSLv2:RC4+RSA:+HIGH:+MEDIUM:+LOW"
-    end
-  else
-    if DEFAULT_PARAMS[:options]
-      DEFAULT_PARAMS[:options] |= OpenSSL::SSL::OP_NO_SSLv2
-    else
-      DEFAULT_PARAMS[:options] = OpenSSL::SSL::OP_NO_SSLv2
-    end
-    DEFAULT_PARAMS[:ciphers] << ':!SSLv2'
-
-    def initialize(*args)
-      __original_initialize(*args)
-      params = {
-        :options => DEFAULT_PARAMS[:options],
-        :ciphers => DEFAULT_PARAMS[:ciphers],
-      }
-      set_params(params)
-    end
-  end
-end

data/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)
+  rescue => detail
+    raise "Can't load #{device.provider} for #{device.name}: #{detail}"
+  end
+
+  # for tests reset
+  def self.clear
+    @current = nil
+  end
+end

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

@@ -0,0 +1,27 @@
+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)
+    @url = URI.parse(url)
+
+    @autoloader = Puppet::Util::Autoload.new(
+      self,
+      "puppet/util/network_device/transport",
+      :wrap => false
+    )
+
+    if @autoloader.load(@url.scheme)
+      @transport = Puppet::Util::NetworkDevice::Transport.const_get(@url.scheme.capitalize).new
+      @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/lib/puppet/util/network_device/cisco.rb

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

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

@@ -0,0 +1,256 @@
+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)
+    @enable_password = options[:enable_password] || parse_enable(@url.query)
+    transport.default_prompt = /[#>]\s?\z/n
+  end
+
+  def parse_enable(query)
+    return $1 if query =~ /enable=(.*)/
+  end
+
+  def command(cmd=nil)
+    Puppet.debug("command #{cmd}")
+    transport.connect
+    login
+    transport.command("terminal length 0") do |out|
+      enable if out =~ />\s?\z/n
+    end
+    find_capabilities
+    out = execute(cmd) if cmd
+    yield self if block_given?
+    transport.close
+    out
+  end
+
+  def execute(cmd)
+    transport.command(cmd)
+  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 = transport.command("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},
+    :GigEthernet => %w{GigabitEthernet GigEthernet GigEth GE Gi G},
+    :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 canonalize_ifname(interface)
+    IF.each do |k,ifnames|
+      if found = ifnames.find { |ifname| interface =~ /^#{ifname}\s*\d/i }
+        interface =~ /^#{found}(.+)\b/i
+        return "#{k.to_s}#{$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 = canonalize_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(canonalize_ifname(name), transport)
+  end
+
+  def parse_interface(name)
+    resource = {}
+    out = transport.command("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 = transport.command("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 = transport.command(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| canonalize_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| canonalize_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"
+      transport.command("conf t")
+      transport.command("no vlan #{id}")
+      transport.command("exit")
+      return
+    end
+
+    # We're creating or updating an entry
+    transport.command("conf t")
+    transport.command("vlan #{id}")
+    [is.keys, should.keys].flatten.uniq.each do |property|
+      Puppet.debug("trying property: #{property}: #{should[property]}")
+      next if property != :description
+      transport.command("name #{should[property]}")
+    end
+    transport.command("exit")
+    transport.command("exit")
+  end
+
+  def parse_trunking(interface)
+    trunking = {}
+    out = transport.command("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
+        else
+          raise "Unknown switchport mode: #{$1} for #{interface}"
+        end
+      when /^Administrative Trunking Encapsulation:\s+(.*)$/
+        case $1
+        when "dot1q","isl"
+          trunking[:encapsulation] = $1.to_sym if trunking[:mode] == :trunk
+        else
+          raise "Unknown switchport encapsulation: #{$1} for #{interface}"
+        end
+      when /^Access Mode VLAN:\s+(.*) \(\(Inactive\)\)$/
+        # nothing
+      when /^Access Mode VLAN:\s+(.*) \(.*\)$/
+        trunking[:native_vlan] = $1 if trunking[:mode] == :access
+      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