puppet 5.0.0 → 6.0.0

data/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}") 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/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 canonalize_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 = 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 = 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| 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") % { 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

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

@@ -1,72 +0,0 @@
-
-require 'puppet/util/network_device/cisco'
-require 'puppet/util/network_device/ipcalc'
-
-# this retrieves facts from a cisco device
-class Puppet::Util::NetworkDevice::Cisco::Facts
-
-  attr_reader :transport
-
-  def initialize(transport)
-    @transport = transport
-  end
-
-  def retrieve
-    facts = {}
-    facts.merge(parse_show_ver)
-  end
-
-  def parse_show_ver
-    facts = {}
-    out = @transport.command("sh ver")
-    lines = out.split("\n")
-    lines.shift; lines.pop
-    lines.each do |l|
-      case l
-      # cisco WS-C2924C-XL (PowerPC403GA) processor (revision 0x11) with 8192K/1024K bytes of memory.
-      # Cisco 1841 (revision 5.0) with 355328K/37888K bytes of memory.
-      # Cisco 877 (MPC8272) processor (revision 0x200) with 118784K/12288K bytes of memory.
-      # cisco WS-C2960G-48TC-L (PowerPC405) processor (revision C0) with 61440K/4088K bytes of memory.
-      # cisco WS-C2950T-24 (RC32300) processor (revision R0) with 19959K bytes of memory.
-      when /[cC]isco ([\w-]+) (?:\(([\w-]+)\) processor )?\(revision (.+)\) with (\d+[KMG])(?:\/(\d+[KMG]))? bytes of memory\./
-        facts[:hardwaremodel] = $1
-        facts[:processor] = $2 if $2
-        facts[:hardwarerevision] = $3
-        facts[:memorysize] = $4
-      # uptime
-      # Switch uptime is 1 year, 12 weeks, 6 days, 22 hours, 32 minutes
-      # c2950 uptime is 3 weeks, 1 day, 23 hours, 36 minutes
-      # c2960 uptime is 2 years, 27 weeks, 5 days, 21 hours, 30 minutes
-      # router uptime is 5 weeks, 1 day, 3 hours, 30 minutes
-      when /^\s*([\w-]+)\s+uptime is (.*?)$/
-        facts[:hostname] = $1
-        facts[:uptime] = $2
-        facts[:uptime_seconds] = uptime_to_seconds($2)
-        facts[:uptime_days] = facts[:uptime_seconds] / 86400
-      # "IOS (tm) C2900XL Software (C2900XL-C3H2S-M), Version 12.0(5)WC10, RELEASE SOFTWARE (fc1)"=> { :operatingsystem => "IOS", :operatingsystemrelease => "12.0(5)WC10", :operatingsystemmajrelease => "12.0", :operatingsystemfeature => "C3H2S"},
-      # "IOS (tm) C2950 Software (C2950-I6K2L2Q4-M), Version 12.1(22)EA8a, RELEASE SOFTWARE (fc1)"=> { :operatingsystem => "IOS", :operatingsystemrelease => "12.1(22)EA8a", :operatingsystemmajrelease => "12.1", :operatingsystemfeature => "I6K2L2Q4"},
-      # "Cisco IOS Software, C2960 Software (C2960-LANBASEK9-M), Version 12.2(44)SE, RELEASE SOFTWARE (fc1)"=>{ :operatingsystem => "IOS", :operatingsystemrelease => "12.2(44)SE", :operatingsystemmajrelease => "12.2", :operatingsystemfeature => "LANBASEK9"},
-      # "Cisco IOS Software, C870 Software (C870-ADVIPSERVICESK9-M), Version 12.4(11)XJ4, RELEASE SOFTWARE (fc2)"=>{ :operatingsystem => "IOS", :operatingsystemrelease => "12.4(11)XJ40", :operatingsystemmajrelease => "12.4XJ", :operatingsystemfeature => "ADVIPSERVICESK9"},
-      # "Cisco IOS Software, 1841 Software (C1841-ADVSECURITYK9-M), Version 12.4(24)T4, RELEASE SOFTWARE (fc2)" =>{ :operatingsystem => "IOS", :operatingsystemrelease => "12.4(24)T4", :operatingsystemmajrelease => "12.4T", :operatingsystemfeature => "ADVSECURITYK9"},
-      when /(?:Cisco )?(IOS)\s*(?:\(tm\) |Software, )?(?:\w+)\s+Software\s+\(\w+-(\w+)-\w+\), Version ([0-9.()A-Za-z]+),/
-        facts[:operatingsystem] = $1
-        facts[:operatingsystemrelease] = $3
-        facts[:operatingsystemmajrelease] = ios_major_version(facts[:operatingsystemrelease])
-        facts[:operatingsystemfeature] = $2
-      end
-    end
-    facts
-  end
-
-  def ios_major_version(version)
-    version.gsub(/^(\d+)\.(\d+)\(.+\)([A-Z]+)([\da-z]+)?/, '\1.\2\3')
-  end
-
-  def uptime_to_seconds(uptime)
-    captures = (uptime.match /^(?:(\d+) years?,)?\s*(?:(\d+) weeks?,)?\s*(?:(\d+) days?,)?\s*(?:(\d+) hours?,)?\s*(\d+) minutes?$/).captures
-    captures.zip([31536000, 604800, 86400, 3600, 60]).inject(0) do |total, (x,y)|
-      total + (x.nil? ? 0 : x.to_i * y)
-    end
-  end
-
-end

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

@@ -1,94 +0,0 @@
-require 'puppet/util/network_device/cisco'
-require 'puppet/util/network_device/ipcalc'
-
-# this manages setting properties to an interface in a cisco switch or router
-class Puppet::Util::NetworkDevice::Cisco::Interface
-
-  include Puppet::Util::NetworkDevice::IPCalc
-  extend Puppet::Util::NetworkDevice::IPCalc
-
-  attr_reader :transport, :name
-
-  def initialize(name, transport)
-    @name = name
-    @transport = transport
-  end
-
-  COMMANDS = {
-    # property     => order, ios command/block/array
-    :description   => [1, "description %s"],
-    :speed         => [2, "speed %s"],
-    :duplex        => [3, "duplex %s"],
-    :encapsulation => [4, "switchport trunk encapsulation %s"],
-    :mode          => [5, "switchport mode %s"],
-    :access_vlan   => [6, "switchport access vlan %s"],
-    :native_vlan   => [7, "switchport trunk native vlan %s"],
-    :allowed_trunk_vlans => [8, "switchport trunk allowed vlan %s"],
-    :etherchannel  => [9, ["channel-group %s", "port group %s"]],
-    :ipaddress     => [10,
-      lambda do |prefix,ip,option|
-        ip.ipv6? ? "ipv6 address #{ip.to_s}/#{prefix} #{option}" :
-                   "ip address #{ip.to_s} #{netmask(Socket::AF_INET,prefix)}"
-      end],
-    :ensure        => [11, lambda { |value| value == :present ? "no shutdown" : "shutdown" } ]
-  }
-
-  def update(is={}, should={})
-    Puppet.debug("Updating interface #{name}")
-    command("conf t")
-    command("interface #{name}")
-
-    # apply changes in a defined order for cisco IOS devices
-    [is.keys, should.keys].flatten.uniq.sort {|a,b| COMMANDS[a][0] <=> COMMANDS[b][0] }.each do |property|
-      # Work around for old documentation which shows :native_vlan used for access vlan
-      if property == :access_vlan and should[:mode] != :trunk and should[:access_vlan].nil?
-        should[:access_vlan] = should[:native_vlan]
-      end
-
-      Puppet.debug("comparing #{property}: #{is[property]} == #{should[property]}")
-
-      # They're equal, so do nothing.
-      next if is[property] == should[property]
-
-      # We're deleting it
-      if should[property] == :absent or should[property].nil?
-        execute(property, is[property], "no ")
-        next
-      end
-
-      # We're replacing an existing value or creating a new one
-      execute(property, should[property])
-    end
-
-    command("exit")
-    command("exit")
-  end
-
-  def execute(property, value, prefix='')
-    case COMMANDS[property][1]
-    when Array
-      COMMANDS[property][1].each do |command|
-        transport.command(prefix + command % value) do |out|
-          break unless out =~ /^%/
-        end
-      end
-    when String
-      command(prefix + COMMANDS[property][1] % value)
-    when Proc
-      value = [value] unless value.is_a?(Array)
-      value.each do |v|
-        command(prefix + COMMANDS[property][1].call(*v))
-      end
-    end
-  end
-
-  def command(command)
-    transport.command(command) do |out|
-      if out =~ /^%/mo or out =~ /^Command rejected:/mo
-        # strip off the command just sent
-        error = out.sub(command,'')
-        Puppet.err _("Error while executing '%{command}', device returned: %{error}") % { command: command, error: error }
-      end
-    end
-  end
-end

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

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

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

@@ -1,68 +0,0 @@
-require 'puppet/util/network_device'
-
-module Puppet::Util::NetworkDevice::IPCalc
-
-  # This is a rip-off of authstore
-  Octet = '(\d|[1-9]\d|1\d\d|2[0-4]\d|25[0-5])'
-  IPv4 = "#{Octet}\.#{Octet}\.#{Octet}\.#{Octet}"
-  IPv6_full    = "_:_:_:_:_:_:_:_|_:_:_:_:_:_::_?|_:_:_:_:_::((_:)?_)?|_:_:_:_::((_:){0,2}_)?|_:_:_::((_:){0,3}_)?|_:_::((_:){0,4}_)?|_::((_:){0,5}_)?|::((_:){0,6}_)?"
-  IPv6_partial = "_:_:_:_:_:_:|_:_:_:_::(_:)?|_:_::(_:){0,2}|_::(_:){0,3}"
-  IP = "#{IPv4}|#{IPv6_full}".gsub(/_/,'([0-9a-fA-F]{1,4})').gsub(/\(/,'(?:')
-
-  def parse(value)
-    case value
-    when /^(#{IP})\/(\d+)$/  # 12.34.56.78/24, a001:b002::efff/120, c444:1000:2000::9:192.168.0.1/112
-      [$2.to_i,IPAddr.new($1)]
-    when /^(#{IP})$/           # 10.20.30.40,
-      value = IPAddr.new(value)
-      [bits(value.family),value]
-    end
-  end
-
-  def bits(family)
-    family == Socket::AF_INET6 ? 128 : 32
-  end
-
-  def fullmask(family)
-    (1 << bits(family)) - 1
-  end
-
-  def mask(family, length)
-    (1 << (bits(family) - length)) - 1
-  end
-
-  # returns ip address netmask from prefix length
-  def netmask(family, length)
-    IPAddr.new(fullmask(family) & ~mask(family, length) , family)
-  end
-
-  # returns an IOS wildmask
-  def wildmask(family, length)
-    IPAddr.new(mask(family, length) , family)
-  end
-
-  # returns ip address prefix length from netmask
-  def prefix_length(netmask)
-    mask_addr = netmask.to_i
-    return 0 if mask_addr == 0
-    length=32
-    if (netmask.ipv6?)
-      length=128
-    end
-
-    mask = mask_addr < 2**length ? length : 128
-
-    mask.times do
-        if ((mask_addr & 1) == 1)
-            break
-        end
-        mask_addr = mask_addr >> 1
-        mask = mask - 1
-    end
-    mask
-  end
-
-  def linklocal?(ip)
-  end
-
-end