From aa34b72f9873c52bb02eb748dbdf40c51592dab9 Mon Sep 17 00:00:00 2001
From: Brice Figureau <brice-puppet@daysofwonder.com>
Date: Mon, 3 Jan 2011 19:45:25 +0100
Subject: Introduce a module for some IP computations

Those will be used to parse IPs, compute netmaks or prefix length.
Unfortunately ruby IPAddr doesn't support those directly.

Signed-off-by: Brice Figureau <brice-puppet@daysofwonder.com>
---
 lib/puppet/util/network_device/ipcalc.rb | 68 ++++++++++++++++++++++++++++++++
 1 file changed, 68 insertions(+)
 create mode 100644 lib/puppet/util/network_device/ipcalc.rb

(limited to 'lib')

diff --git a/lib/puppet/util/network_device/ipcalc.rb b/lib/puppet/util/network_device/ipcalc.rb
new file mode 100644
index 000000000..2b4f360b7
--- /dev/null
+++ b/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
\ No newline at end of file
-- 
cgit 


From c947a6dee2134964e04146d6da7b1d1c4f814169 Mon Sep 17 00:00:00 2001
From: Brice Figureau <brice-puppet@daysofwonder.com>
Date: Mon, 3 Jan 2011 19:48:18 +0100
Subject: Remote Network Device transport system

This is the base for upcoming telnet and ssh transport mechanism
to send commands to network devices.

Signed-off-by: Brice Figureau <brice-puppet@daysofwonder.com>
---
 lib/puppet/util/network_device/transport.rb      |  5 +++++
 lib/puppet/util/network_device/transport/base.rb | 26 ++++++++++++++++++++++++
 2 files changed, 31 insertions(+)
 create mode 100644 lib/puppet/util/network_device/transport.rb
 create mode 100644 lib/puppet/util/network_device/transport/base.rb

(limited to 'lib')

diff --git a/lib/puppet/util/network_device/transport.rb b/lib/puppet/util/network_device/transport.rb
new file mode 100644
index 000000000..e64fe9b69
--- /dev/null
+++ b/lib/puppet/util/network_device/transport.rb
@@ -0,0 +1,5 @@
+# stub
+module Puppet::Util::NetworkDevice
+  module Transport
+  end
+end
\ No newline at end of file
diff --git a/lib/puppet/util/network_device/transport/base.rb b/lib/puppet/util/network_device/transport/base.rb
new file mode 100644
index 000000000..1d62209cb
--- /dev/null
+++ b/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
\ No newline at end of file
-- 
cgit 


From 358245a823c1e2ed6fa2351130cf98678bd02e0d Mon Sep 17 00:00:00 2001
From: Brice Figureau <brice-puppet@daysofwonder.com>
Date: Mon, 3 Jan 2011 19:49:12 +0100
Subject: Telnet transport to connect to remote network device

It is based on net/telnet.

Signed-off-by: Brice Figureau <brice-puppet@daysofwonder.com>
---
 lib/puppet/util/network_device/transport/telnet.rb | 42 ++++++++++++++++++++++
 1 file changed, 42 insertions(+)
 create mode 100644 lib/puppet/util/network_device/transport/telnet.rb

(limited to 'lib')

diff --git a/lib/puppet/util/network_device/transport/telnet.rb b/lib/puppet/util/network_device/transport/telnet.rb
new file mode 100644
index 000000000..e55079e06
--- /dev/null
+++ b/lib/puppet/util/network_device/transport/telnet.rb
@@ -0,0 +1,42 @@
+require 'puppet/util/network_device'
+require 'puppet/util/network_device/transport'
+require 'puppet/util/network_device/transport/base'
+require 'net/telnet'
+
+class Puppet::Util::NetworkDevice::Transport::Telnet < Puppet::Util::NetworkDevice::Transport::Base
+    def initialize
+      super
+    end
+
+    def handles_login?
+      false
+    end
+
+    def connect
+      @telnet = Net::Telnet::new("Host" => host, "Port" => port || 23,
+                                 "Timeout" => 10,
+                                 "Prompt" => default_prompt, "Output_log" => "/tmp/out.log")
+    end
+
+    def close
+      @telnet.close if @telnet
+      @telnet = nil
+    end
+
+    def expect(prompt)
+      @telnet.waitfor(prompt) do |out|
+        yield out if block_given?
+      end
+    end
+
+    def command(cmd, options = {})
+      send(cmd)
+      expect(options[:prompt] || default_prompt) do |output|
+        yield output if block_given?
+      end
+    end
+
+    def send(line)
+      @telnet.puts(line)
+    end
+end
\ No newline at end of file
-- 
cgit 


From 6560da52674dfce10a622b633a9ed511f75b0a89 Mon Sep 17 00:00:00 2001
From: Brice Figureau <brice-puppet@daysofwonder.com>
Date: Mon, 3 Jan 2011 19:50:20 +0100
Subject: Ssh transport for network device management

It is an adapatation of net-ssh-telnet, so that net-ssh conforms to
a saner interface for consumer.

Signed-off-by: Brice Figureau <brice-puppet@daysofwonder.com>
---
 lib/puppet/feature/ssh.rb                       |   4 +
 lib/puppet/util/network_device/transport/ssh.rb | 115 ++++++++++++++++++++++++
 2 files changed, 119 insertions(+)
 create mode 100644 lib/puppet/feature/ssh.rb
 create mode 100644 lib/puppet/util/network_device/transport/ssh.rb

(limited to 'lib')

diff --git a/lib/puppet/feature/ssh.rb b/lib/puppet/feature/ssh.rb
new file mode 100644
index 000000000..82fe19882
--- /dev/null
+++ b/lib/puppet/feature/ssh.rb
@@ -0,0 +1,4 @@
+require 'puppet/util/feature'
+
+Puppet.features.rubygems?
+Puppet.features.add(:ssh, :libs => %{net/ssh})
diff --git a/lib/puppet/util/network_device/transport/ssh.rb b/lib/puppet/util/network_device/transport/ssh.rb
new file mode 100644
index 000000000..b3cf51b8a
--- /dev/null
+++ b/lib/puppet/util/network_device/transport/ssh.rb
@@ -0,0 +1,115 @@
+
+require 'puppet/util/network_device'
+require 'puppet/util/network_device/transport'
+require 'puppet/util/network_device/transport/base'
+require 'net/ssh'
+
+# 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, :verbose
+
+  def initialize
+    super
+  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"
+    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 { |ch,data| @buf << data }
+        ch.on_extended_data { |ch,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
+    @channel.close if @channel
+    @channel = nil
+    @ssh.close if @ssh
+  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
\ No newline at end of file
-- 
cgit 


From 596571fd2b03957e7ed185856ee649c1e610716c Mon Sep 17 00:00:00 2001
From: Brice Figureau <brice-puppet@daysofwonder.com>
Date: Mon, 3 Jan 2011 19:45:51 +0100
Subject: Base class for network device based providers

This is the common bits of all future network device providers
that are using prefetching/flushing to limit the number of
calls to the remote network device.

The idea is that we need one transaction to prefetch and one
to flush each instance.

Implementors needs to implement lookup which returns a hash
of the found entity, and flush to update the remote device.

Signed-off-by: Brice Figureau <brice-puppet@daysofwonder.com>
---
 lib/puppet/provider/network_device.rb | 59 +++++++++++++++++++++++++++++++++++
 1 file changed, 59 insertions(+)
 create mode 100644 lib/puppet/provider/network_device.rb

(limited to 'lib')

diff --git a/lib/puppet/provider/network_device.rb b/lib/puppet/provider/network_device.rb
new file mode 100644
index 000000000..58865fddc
--- /dev/null
+++ b/lib/puppet/provider/network_device.rb
@@ -0,0 +1,59 @@
+
+# This is the base class of all prefetched network device provider
+class Puppet::Provider::NetworkDevice < Puppet::Provider
+
+  def self.lookup(url, name)
+    raise "This provider doesn't implement the necessary lookup method"
+  end
+
+  def self.prefetch(resources)
+    resources.each do |name, resource|
+      if result = lookup(resource[:device_url], name)
+        result[:ensure] = :present
+        resource.provider = new(result)
+      else
+        resource.provider = new(:ensure => :absent)
+      end
+    end
+  end
+
+  def exists?
+    @property_hash[:ensure] != :absent
+  end
+
+  def initialize(*args)
+    super
+
+    # Make a duplicate, so that we have a copy for comparison
+    # at the end.
+    @properties = @property_hash.dup
+  end
+
+  def create
+    @property_hash[:ensure] = :present
+    self.class.resource_type.validproperties.each do |property|
+      if val = resource.should(property)
+        @property_hash[property] = val
+      end
+    end
+  end
+
+  def destroy
+    @property_hash[:ensure] = :absent
+  end
+
+  def flush
+    @property_hash.clear
+  end
+
+  def self.instances
+  end
+
+  def former_properties
+    @properties.dup
+  end
+
+  def properties
+    @property_hash.dup
+  end
+end
\ No newline at end of file
-- 
cgit 


From 1cb18410732a4b51efa0a106d4a1437daef08fc5 Mon Sep 17 00:00:00 2001
From: Brice Figureau <brice-puppet@daysofwonder.com>
Date: Mon, 3 Jan 2011 19:47:03 +0100
Subject: Cisco Switch/Router Interface management

This patch introduces managing remotely cisco IOS network devices
through ssh or telnet with a puppet type/provider.

This patch allows to manage router/switch interface
with the interface type:

interface {
	"FastEthernet 0/1":
		device_url => "ssh://user:pass@cisco2960.domain.com/",
		mode => trunk,
		encapsulation => dot1q,
		trunk_allowed_vlans => "1-99,200,253",
		description => "to back bone router"
}

It is possible with this patch to set interface:
 * mode (access or trunk)
 * native vlan (only for access mode)
 * speed (auto or a given speed)
 * duplex (auto, half or full)
 * trunk encapsulation
 * allowed trunk vlan
 * ipv4 addresses
 * ipv6 addresses
 * etherchannel membership

The interface name (at least for the cisco provider) can be any
shorthand interface name a switch or router can use.

The device url should conform to:
 * scheme: either telnet or ssh
 * user: can be absent depending on switch/router line config
 * pass: must be present
 * port: optional
 * an optional enable password can be mentioned in the url query string

Ex:
To connect to a switch with a line password and an enable password:
"telnet://:letmein@cisco29224XL.domain.com/?enable=letmeinagain"

To connect to a switch/router through ssh and a privileged user:
"ssh://brice:letmein@cisco1841L.domain.com/"

Note:
This patch only includes a Cisco IOS provider. Also terminology adopted
in the various types are mostly the ones used in Cisco devices.
This patch was tested against:
* (really old) Cisco switch 2924XL with ios 12.0(5)WC10
* Cisco router 1841 with ios 12.4(15)T8
* Cisco router 877 with ios 12.4(11)XJ4
* Cisco switch 2960G with ios 12.2(44)SE

Signed-off-by: Brice Figureau <brice-puppet@daysofwonder.com>
---
 lib/puppet/provider/interface/base.rb             |   0
 lib/puppet/provider/interface/cisco.rb            |  33 ++++
 lib/puppet/type/interface.rb                      | 107 ++++++++++
 lib/puppet/type/router.rb                         |  14 ++
 lib/puppet/util/network_device.rb                 |   2 +
 lib/puppet/util/network_device/base.rb            |  29 +++
 lib/puppet/util/network_device/cisco.rb           |   4 +
 lib/puppet/util/network_device/cisco/device.rb    | 225 ++++++++++++++++++++++
 lib/puppet/util/network_device/cisco/interface.rb |  82 ++++++++
 9 files changed, 496 insertions(+)
 create mode 100644 lib/puppet/provider/interface/base.rb
 create mode 100644 lib/puppet/provider/interface/cisco.rb
 create mode 100644 lib/puppet/type/interface.rb
 create mode 100644 lib/puppet/type/router.rb
 create mode 100644 lib/puppet/util/network_device.rb
 create mode 100644 lib/puppet/util/network_device/base.rb
 create mode 100644 lib/puppet/util/network_device/cisco.rb
 create mode 100644 lib/puppet/util/network_device/cisco/device.rb
 create mode 100644 lib/puppet/util/network_device/cisco/interface.rb

(limited to 'lib')

diff --git a/lib/puppet/provider/interface/base.rb b/lib/puppet/provider/interface/base.rb
new file mode 100644
index 000000000..e69de29bb
diff --git a/lib/puppet/provider/interface/cisco.rb b/lib/puppet/provider/interface/cisco.rb
new file mode 100644
index 000000000..f3bd202e9
--- /dev/null
+++ b/lib/puppet/provider/interface/cisco.rb
@@ -0,0 +1,33 @@
+require 'puppet/util/network_device/cisco/device'
+require 'puppet/provider/network_device'
+
+Puppet::Type.type(:interface).provide :cisco, :parent => Puppet::Provider::NetworkDevice do
+
+  desc "Cisco switch/router provider for interface."
+
+  mk_resource_methods
+
+  def self.lookup(url, name)
+    interface = nil
+    network_gear = Puppet::Util::NetworkDevice::Cisco::Device.new(url)
+    network_gear.command do |ng|
+      interface = network_gear.interface(name)
+    end
+    interface
+  end
+
+  def initialize(*args)
+    super
+  end
+
+  def flush
+    device.command do |device|
+      device.new_interface(name).update(former_properties, properties)
+    end
+    super
+  end
+
+  def device
+    @device ||= Puppet::Util::NetworkDevice::Cisco::Device.new(resource[:device_url])
+  end
+end
diff --git a/lib/puppet/type/interface.rb b/lib/puppet/type/interface.rb
new file mode 100644
index 000000000..7560a0552
--- /dev/null
+++ b/lib/puppet/type/interface.rb
@@ -0,0 +1,107 @@
+#
+# Manages an interface on a given router or switch
+#
+
+require 'puppet/util/network_device/ipcalc'
+
+Puppet::Type.newtype(:interface) do
+
+    @doc = "This represents a router or switch interface. It is possible to manage
+    interface mode (access or trunking, native vlan and encapsulation), 
+    switchport characteristics (speed, duplex)."
+
+    ensurable do
+      defaultvalues
+
+      aliasvalue :shutdown, :absent
+      aliasvalue :no_shutdown, :present
+
+      defaultto { :no_shutdown }
+    end
+
+    newparam(:name) do
+      desc "Interface name"
+    end
+
+    newparam(:device_url) do
+      desc "Url to connect to a router or switch."
+    end
+
+    newproperty(:description) do
+      desc "Interface description."
+
+      defaultto { @resource[:name] }
+    end
+
+    newproperty(:speed) do
+      desc "Interface speed."
+      newvalues(:auto, /^\d+/)
+    end
+
+    newproperty(:duplex) do
+      desc "Interface duplex."
+      newvalues(:auto, :full, :half)
+    end
+
+    newproperty(:native_vlan) do
+      desc "Interface native vlan (for access mode only)."
+      newvalues(/^\d+/)
+    end
+
+    newproperty(:encapsulation) do
+      desc "Interface switchport encapsulation."
+      newvalues(:none, :dot1q, :isl )
+    end
+
+    newproperty(:mode) do
+      desc "Interface switchport mode."
+      newvalues(:access, :trunk)
+    end
+
+    newproperty(:allowed_trunk_vlans) do
+      desc "Allowed list of Vlans that this trunk can forward."
+      newvalues(:all, /./)
+    end
+
+    newproperty(:etherchannel) do
+      desc "Channel group this interface is part of."
+      newvalues(/^\d+/)
+    end
+
+    newproperty(:ipaddress, :array_matching => :all) do
+      include Puppet::Util::NetworkDevice::IPCalc
+
+      desc "IP Address of this interface (it might not be possible to set an interface IP address 
+      it depends on the interface type and device type).
+      Valid format of ip addresses are:
+       * IPV4, like 127.0.0.1
+       * IPV4/prefixlength like 127.0.1.1/24
+       * IPV6/prefixlength like FE80::21A:2FFF:FE30:ECF0/128
+       * an optional suffix for IPV6 addresses from this list: eui-64, link-local
+      It is also possible to use an array of values. 
+      "
+
+      validate do |values|
+        values = [values] unless values.is_a?(Array)
+        values.each do |value|
+          self.fail "Invalid interface ip address" unless parse(value.gsub(/\s*(eui-64|link-local)\s*$/,''))
+        end
+      end
+
+      munge do |value|
+        option = value =~ /eui-64|link-local/i ? value.gsub(/^.*?\s*(eui-64|link-local)\s*$/,'\1') : nil
+        [parse(value.gsub(/\s*(eui-64|link-local)\s*$/,'')), option].flatten
+      end
+
+      def value_to_s(value)
+        value = [value] unless value.is_a?(Array)
+        value.map{ |v| "#{v[1].to_s}/#{v[0]} #{v[2]}"}.join(",")
+      end
+
+      def change_to_s(currentvalue, newvalue)
+        currentvalue = value_to_s(currentvalue) if currentvalue != :absent
+        newvalue = value_to_s(newvalue)
+        super(currentvalue, newvalue)
+      end
+    end
+end
diff --git a/lib/puppet/type/router.rb b/lib/puppet/type/router.rb
new file mode 100644
index 000000000..648389d39
--- /dev/null
+++ b/lib/puppet/type/router.rb
@@ -0,0 +1,14 @@
+#
+# Manage a router abstraction
+#
+
+module Puppet
+  newtype(:router) do
+    @doc = "Manages connected router."
+
+    newparam(:url) do
+      desc "An URL to access the router of the form (ssh|telnet)://user:pass:enable@host/."
+      isnamevar
+    end
+  end
+end
diff --git a/lib/puppet/util/network_device.rb b/lib/puppet/util/network_device.rb
new file mode 100644
index 000000000..bca66016b
--- /dev/null
+++ b/lib/puppet/util/network_device.rb
@@ -0,0 +1,2 @@
+module Puppet::Util::NetworkDevice
+end
\ No newline at end of file
diff --git a/lib/puppet/util/network_device/base.rb b/lib/puppet/util/network_device/base.rb
new file mode 100644
index 000000000..ff96c8693
--- /dev/null
+++ b/lib/puppet/util/network_device/base.rb
@@ -0,0 +1,29 @@
+require 'puppet/util/autoload'
+require 'uri'
+require 'puppet/util/network_device/transport'
+require 'puppet/util/network_device/transport/base'
+
+module Puppet::Util::NetworkDevice
+  class 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
+end
\ No newline at end of file
diff --git a/lib/puppet/util/network_device/cisco.rb b/lib/puppet/util/network_device/cisco.rb
new file mode 100644
index 000000000..c03a00104
--- /dev/null
+++ b/lib/puppet/util/network_device/cisco.rb
@@ -0,0 +1,4 @@
+
+module Puppet::Util::NetworkDevice::Cisco
+
+end
\ No newline at end of file
diff --git a/lib/puppet/util/network_device/cisco/device.rb b/lib/puppet/util/network_device/cisco/device.rb
new file mode 100644
index 000000000..97489bd8c
--- /dev/null
+++ b/lib/puppet/util/network_device/cisco/device.rb
@@ -0,0 +1,225 @@
+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 '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 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 = { :id => $1, :name => $2, :status => $3, :interfaces => [] }
+        if $4.strip.length > 0
+          vlan[:interfaces] = $4.strip.split(/\s*,\s*/).map{ |ifn| canonalize_ifname(ifn) }
+        end
+        vlans[vlan[:id]] = 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 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
diff --git a/lib/puppet/util/network_device/cisco/interface.rb b/lib/puppet/util/network_device/cisco/interface.rb
new file mode 100644
index 000000000..63d5492a7
--- /dev/null
+++ b/lib/puppet/util/network_device/cisco/interface.rb
@@ -0,0 +1,82 @@
+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"],
+    :native_vlan   => [4, "switchport access vlan %s"],
+    :encapsulation => [5, "switchport trunk encapsulation %s"],
+    :mode          => [6, "switchport mode %s"],
+    :allowed_trunk_vlans => [7, "switchport trunk allowed vlan %s"],
+    :etherchannel  => [8, ["channel-group %s", "port group %s"]],
+    :ipaddress     => [9,
+      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        => [10, 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 orders for cisco IOS devices
+    [is.keys, should.keys].flatten.uniq.sort {|a,b| COMMANDS[a][0] <=> COMMANDS[b][0] }.each do |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 |value|
+        command(prefix + COMMANDS[property][1].call(*value))
+      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
\ No newline at end of file
-- 
cgit 


From 28e3db87a105eba5eddbb11167d0a6c33b18f8ce Mon Sep 17 00:00:00 2001
From: Brice Figureau <brice-puppet@daysofwonder.com>
Date: Sun, 2 Jan 2011 19:26:19 +0100
Subject: Add management of router/switchs global vlans

This allows to manage the global device list of vlans.
Currently supports only cisco IOS devices.

This is as easy as:

Vlan {
 device_url => "ssh://user:pass@switch.domain.com/"
}

vlan {
 "200": description => "R&D";
 "99":  description => "Management";
}

The device_url conforms to the same specs as for the interface
type.

Signed-off-by: Brice Figureau <brice-puppet@daysofwonder.com>
---
 lib/puppet/provider/vlan/cisco.rb              | 34 ++++++++++++++++++++++++++
 lib/puppet/type/vlan.rb                        | 24 ++++++++++++++++++
 lib/puppet/util/network_device/cisco/device.rb | 25 +++++++++++++++++--
 3 files changed, 81 insertions(+), 2 deletions(-)
 create mode 100644 lib/puppet/provider/vlan/cisco.rb
 create mode 100644 lib/puppet/type/vlan.rb

(limited to 'lib')

diff --git a/lib/puppet/provider/vlan/cisco.rb b/lib/puppet/provider/vlan/cisco.rb
new file mode 100644
index 000000000..46e172c73
--- /dev/null
+++ b/lib/puppet/provider/vlan/cisco.rb
@@ -0,0 +1,34 @@
+require 'puppet/util/network_device/cisco/device'
+require 'puppet/provider/network_device'
+
+Puppet::Type.type(:vlan).provide :cisco, :parent => Puppet::Provider::NetworkDevice do
+
+  desc "Cisco switch/router provider for vlans."
+
+  mk_resource_methods
+
+  def self.lookup(url, id)
+    vlans = {}
+    device = Puppet::Util::NetworkDevice::Cisco::Device.new(url)
+    device.command do |d|
+      vlans = d.parse_vlans || {}
+    end
+    vlans[id]
+  end
+
+  def initialize(*args)
+    super
+  end
+
+  # Clear out the cached values.
+  def flush
+    device.command do |device|
+      device.update_vlan(resource[:name], former_properties, properties)
+    end
+    super
+  end
+
+  def device
+    @device ||= Puppet::Util::NetworkDevice::Cisco::Device.new(resource[:device_url])
+  end
+end
diff --git a/lib/puppet/type/vlan.rb b/lib/puppet/type/vlan.rb
new file mode 100644
index 000000000..6708ea4f5
--- /dev/null
+++ b/lib/puppet/type/vlan.rb
@@ -0,0 +1,24 @@
+#
+# Manages a Vlan on a given router or switch
+#
+
+Puppet::Type.newtype(:vlan) do
+    @doc = "This represents a router or switch vlan."
+
+    ensurable
+
+    newparam(:name) do
+      desc "Vlan id. It must be a number"
+      isnamevar
+
+      newvalues(/^\d+/)
+    end
+
+    newproperty(:description) do
+      desc "Vlan name"
+    end
+
+    newparam(:device_url) do
+      desc "Url to connect to a router or switch."
+    end
+end
\ No newline at end of file
diff --git a/lib/puppet/util/network_device/cisco/device.rb b/lib/puppet/util/network_device/cisco/device.rb
index 97489bd8c..1f350991a 100644
--- a/lib/puppet/util/network_device/cisco/device.rb
+++ b/lib/puppet/util/network_device/cisco/device.rb
@@ -163,11 +163,11 @@ class Puppet::Util::NetworkDevice::Cisco::Device < Puppet::Util::NetworkDevice::
       case l
             # vlan    name    status
       when /^(\d+)\s+(\w+)\s+(\w+)\s+([a-zA-Z0-9,\/. ]+)\s*$/
-        vlan = { :id => $1, :name => $2, :status => $3, :interfaces => [] }
+        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[:id]] = vlan
+        vlans[vlan[:name]] = vlan
       when /^\s+([a-zA-Z0-9,\/. ]+)\s*$/
         raise "invalid sh vlan summary output" unless vlan
         if $1.strip.length > 0
@@ -179,6 +179,27 @@ class Puppet::Util::NetworkDevice::Cisco::Device < Puppet::Util::NetworkDevice::
     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")
-- 
cgit