puppet 4.4.0-universal-darwin

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

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

@@ -0,0 +1,95 @@
+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
+
+      # Don't change non-operational mode parameters
+      next if property == :access_vlan and should[:mode] == :trunk
+      next if property == :native_vlan and should[:mode] == :access
+      next if property == :encapsulation and should[:mode] == :access
+
+      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|
+      Puppet.err "Error while executing #{command}, device returned #{out}" if out =~ /^%/mo
+    end
+  end
+end

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

@@ -0,0 +1,98 @@
+require 'ostruct'
+require 'puppet/util/watched_file'
+require 'puppet/util/network_device'
+
+class Puppet::Util::NetworkDevice::Config
+
+  def self.main
+    @main ||= self.new
+  end
+
+  def self.devices
+    main.devices || []
+  end
+
+  attr_reader :devices
+
+  def exists?
+    Puppet::FileSystem.exist?(@file.to_str)
+  end
+
+  def initialize
+    @file = Puppet::Util::WatchedFile.new(Puppet[:deviceconfig])
+
+    @devices = {}
+
+    read(true) # force reading at start
+  end
+
+  # Read the configuration file.
+  def read(force = false)
+    return unless exists?
+
+    parse if force or @file.changed?
+  end
+
+  private
+
+  def parse
+    begin
+      devices = {}
+      device = nil
+      File.open(@file) { |f|
+        count = 1
+        f.each { |line|
+          case line
+          when /^\s*#/ # skip comments
+            count += 1
+            next
+          when /^\s*$/  # skip blank lines
+            count += 1
+            next
+          when /^\[([\w.-]+)\]\s*$/ # [device.fqdn]
+            name = $1
+            name.chomp!
+            raise Puppet::Error, "Duplicate device found at line #{count}, already found at #{device.line}" if devices.include?(name)
+            device = OpenStruct.new
+            device.name = name
+            device.line = count
+            device.options = { :debug => false }
+            Puppet.debug "found device: #{device.name} at #{device.line}"
+            devices[name] = device
+          when /^\s*(type|url|debug)(\s+(.+))*$/
+            parse_directive(device, $1, $3, count)
+          else
+            raise Puppet::Error, "Invalid line #{count}: #{line}"
+          end
+          count += 1
+        }
+      }
+    rescue Errno::EACCES => detail
+      Puppet.err "Configuration error: Cannot read #{@file}; cannot serve"
+      #raise Puppet::Error, "Cannot read #{@config}"
+    rescue Errno::ENOENT => detail
+      Puppet.err "Configuration error: '#{@file}' does not exit; cannot serve"
+    end
+
+    @devices = devices
+  end
+
+  def parse_directive(device, var, value, count)
+    case var
+    when "type"
+      device.provider = value
+    when "url"
+      begin
+        URI.parse(value)
+      rescue URI::InvalidURIError
+        raise Puppet::Error, "#{value} is an invalid url"
+      end
+      device.url = value
+    when "debug"
+      device.options[:debug] = true
+    else
+      raise Puppet::Error, "Invalid argument '#{var}' at line #{count}"
+    end
+  end
+
+end

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

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

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

@@ -0,0 +1,5 @@
+require 'puppet/util/network_device'
+
+# stub
+module Puppet::Util::NetworkDevice::Transport
+end

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

@@ -0,0 +1,26 @@
+
+require 'puppet/util/network_device'
+require 'puppet/util/network_device/transport'
+
+class Puppet::Util::NetworkDevice::Transport::Base
+  attr_accessor :user, :password, :host, :port
+  attr_accessor :default_prompt, :timeout
+
+  def initialize
+    @timeout = 10
+  end
+
+  def send(cmd)
+  end
+
+  def expect(prompt)
+  end
+
+  def command(cmd, options = {})
+    send(cmd)
+    expect(options[:prompt] || default_prompt) do |output|
+      yield output if block_given?
+    end
+  end
+
+end

data/lib/puppet/util/network_device/transport/ssh.rb

@@ -0,0 +1,126 @@
+
+require 'puppet/util/network_device'
+require 'puppet/util/network_device/transport'
+require 'puppet/util/network_device/transport/base'
+
+# This is an adaptation/simplification of gem net-ssh-telnet, which aims to have
+# a sane interface to Net::SSH. Credits goes to net-ssh-telnet authors
+class Puppet::Util::NetworkDevice::Transport::Ssh < Puppet::Util::NetworkDevice::Transport::Base
+
+  attr_accessor :buf, :ssh, :channel
+
+  def initialize(verbose = false)
+    super()
+    @verbose = verbose
+    unless Puppet.features.ssh?
+      raise 'Connecting with ssh to a network device requires the \'net/ssh\' ruby library'
+    end
+  end
+
+  def handles_login?
+    true
+  end
+
+  def eof?
+    !! @eof
+  end
+
+  def connect(&block)
+    @output = []
+    @channel_data = ""
+
+    begin
+      Puppet.debug("connecting to #{host} as #{user}")
+      @ssh = Net::SSH.start(host, user, :port => port, :password => password, :timeout => timeout)
+    rescue TimeoutError
+      raise TimeoutError, "timed out while opening an ssh connection to the host", $!.backtrace
+    rescue Net::SSH::AuthenticationFailed
+      raise Puppet::Error, "SSH authentication failure connecting to #{host} as #{user}", $!.backtrace
+    rescue Net::SSH::Exception
+      raise Puppet::Error, "SSH connection failure to #{host}", $!.backtrace
+    end
+
+    @buf = ""
+    @eof = false
+    @channel = nil
+    @ssh.open_channel do |channel|
+      channel.request_pty { |ch,success| raise "failed to open pty" unless success }
+
+      channel.send_channel_request("shell") do |ch, success|
+        raise "failed to open ssh shell channel" unless success
+
+        ch.on_data { |_,data| @buf << data }
+        ch.on_extended_data { |_,type,data|  @buf << data if type == 1 }
+        ch.on_close { @eof = true }
+
+        @channel = ch
+        expect(default_prompt, &block)
+        # this is a little bit unorthodox, we're trying to escape
+        # the ssh loop there while still having the ssh connection up
+        # otherwise we wouldn't be able to return ssh stdout/stderr
+        # for a given call of command.
+        return
+      end
+
+    end
+    @ssh.loop
+
+  end
+
+  def close
+    begin
+      @channel.close if @channel
+      @channel = nil
+      @ssh.close if @ssh
+    rescue IOError
+      Puppet.debug "device terminated ssh session impolitely"
+    end
+  end
+
+  def expect(prompt)
+    line = ''
+    sock = @ssh.transport.socket
+
+    while not @eof
+      break if line =~ prompt and @buf == ''
+      break if sock.closed?
+
+      IO::select([sock], [sock], nil, nil)
+
+      process_ssh
+
+      # at this point we have accumulated some data in @buf
+      # or the channel has been closed
+      if @buf != ""
+        line += @buf.gsub(/\r\n/no, "\n")
+        @buf = ''
+        yield line if block_given?
+      elsif @eof
+        # channel has been closed
+        break if line =~ prompt
+        if line == ''
+          line = nil
+          yield nil if block_given?
+        end
+        break
+      end
+    end
+    Puppet.debug("ssh: expected #{line}") if @verbose
+    line
+  end
+
+  def send(line)
+    Puppet.debug("ssh: send #{line}") if @verbose
+    @channel.send_data(line + "\n")
+  end
+
+  def process_ssh
+    while @buf == "" and not eof?
+      begin
+        @channel.connection.process(0.1)
+      rescue IOError
+        @eof = true
+      end
+    end
+  end
+end