bolt 0.19.1 → 0.20.0

data/vendored/puppet/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/vendored/puppet/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/vendored/puppet/lib/puppet/util/network_device/config.rb

@@ -1,105 +0,0 @@
-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) do |f|
-        file_line_count = 1
-        f.each do |line|
-          case line
-          when /^\s*#/ # skip comments
-            file_line_count += 1
-            next
-          when /^\s*$/  # skip blank lines
-            file_line_count += 1
-            next
-          when /^\[([\w.-]+)\]\s*$/ # [device.fqdn]
-            name = $1
-            name.chomp!
-            if devices.include?(name)
-              file_error_location = Puppet::Util::Errors.error_location(nil, file_line_count)
-              device_error_location = Puppet::Util::Errors.error_location(nil, device.line)
-              raise Puppet::Error, _("Duplicate device found at %{file_error_location}, already found at %{device_error_location}") %
-                  { file_error_location: file_error_location, device_error_location: device_error_location }
-            end
-            device = OpenStruct.new
-            device.name = name
-            device.line = file_line_count
-            device.options = { :debug => false }
-            Puppet.debug "found device: #{device.name} at #{device.line}"
-            devices[name] = device
-          when /^\s*(type|url|debug)(\s+(.+)\s*)*$/
-            parse_directive(device, $1, $3, file_line_count)
-          else
-            error_location_str = Puppet::Util::Errors.error_location(nil, file_line_count)
-            raise Puppet::Error, _("Invalid entry at %{error_location}: %{file_text}") %
-                { error_location: error_location_str, file_text: line }
-          end
-        end
-      end
-    rescue Errno::EACCES
-      Puppet.err _("Configuration error: Cannot read %{file}; cannot serve") % { file: @file }
-      #raise Puppet::Error, "Cannot read #{@config}"
-    rescue Errno::ENOENT
-      Puppet.err _("Configuration error: '%{file}' does not exit; cannot serve") % { file: @file }
-    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") % { value: value }
-      end
-      device.url = value
-    when "debug"
-      device.options[:debug] = true
-    else
-      error_location_str = Puppet::Util::Errors.error_location(nil, count)
-      raise Puppet::Error, _("Invalid argument '%{var}' at %{error_location}") % { var: var, error_location: error_location_str }
-    end
-  end
-
-end

data/vendored/puppet/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

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

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

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

@@ -1,26 +0,0 @@
-
-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/vendored/puppet/lib/puppet/util/network_device/transport/ssh.rb

@@ -1,126 +0,0 @@
-
-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}") % { host: host, user: user }, $!.backtrace
-    rescue Net::SSH::Exception
-      raise Puppet::Error, _("SSH connection failure to %{host}") % { host: 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