netutils 0.1.1

data/lib/netutils/parser.rb

@@ -0,0 +1,30 @@
+require 'netutils/fsm'
+
+class Parser < FSM
+	def initialize
+		super
+		@regexp = Array.new
+	end
+
+	def add(sname, cb, regexp = nil)
+		super(sname, cb)
+		@regexp.push(regexp)
+	end
+
+	def regexp
+		r = @regexp[@state]
+		r = /^.*$/ if r == nil
+		return r
+	end
+
+	def parse(buf)
+		buf.each_line do |l|
+			unless l.chomp! =~ regexp
+				raise(ArgumentError,
+				    "No match at #{state_name}: \"#{l}\" " +
+				    "to #{regexp.to_s}")
+			end
+			send(cb, l, $~)
+		end
+	end
+end

data/lib/netutils/rib.rb

@@ -0,0 +1,80 @@
+require 'ipaddr'
+
+class RIB
+	class Route
+		attr_reader :proto, :dst, :prefixlen, :nh, :interface
+
+		def initialize(proto, dst, nh, interface)
+			dst = ip_address_normalize(dst)
+			@proto     = proto
+			@dst       = dst
+			@prefixlen = prefixlen_get(dst)
+			@nh        = nh
+			@interface = interface
+		end
+
+		def prefixlen_get(dst)
+			return dst.split('/')[1].to_i
+		end
+		private :prefixlen_get
+
+		def ip_address_normalize(dst)
+			# XXX IPv4 dependent...
+			n = dst.count('.')
+			case n
+			when 0, 1, 2
+				ia = dst.split('/')[0]
+				for i in 1..3 - n do
+					ia += '.0'
+				end
+				dst = "#{ia}/#{prefixlen_get(dst)}"
+			when 3
+			else
+				raise(ArgumentError,
+				    "Invalid IP address: #{dst}")
+			end
+			return dst
+		end
+		private :ip_address_normalize
+
+		def tunnel?
+			@interface =~ /^[tT]unnel/
+		end
+
+		def compare(other)
+			return self if ! other
+			if defined?(PREFERRED_NEXTHOPS)
+				PREFERRED_NEXTHOPS.each do |prefix|
+					ir = IPAddr.new(prefix)
+					if ir.include?(@nh) &&
+					    ! ir.include?(other.nh)
+						return self
+					elsif ! ir.include?(@nh) &&
+					    ir.include?(other.nh)
+						return other
+					end
+				end
+			end
+			return other if @prefixlen < other.prefixlen
+			return self
+		end
+	end
+
+	def initialize
+		@rib = []
+	end
+
+	def add(proto, dst, nh, interface)
+		@rib.push(Route.new(proto, dst, nh, interface))
+	end
+
+	def get(dst, proto = nil)
+		m = []
+		@rib.each do |r|
+			next if proto && r.proto != proto
+			m.push(r) if IPAddr.new(r.dst).include?(dst)
+		end
+		return nil if m.empty?
+		return m
+	end
+end

data/lib/netutils/switch.rb

@@ -0,0 +1,402 @@
+require 'netutils/cli'
+require 'netutils/oncequeue'
+
+class Switch
+	module Type
+		ROUTER	= 1
+		SWITCH	= 2
+		BRIDGE	= 3
+		HOST	= 4
+		UNKNOWN	= 5
+	end
+
+	class PortName
+		MAX_ARGS = 3
+
+		attr_reader :numbers
+
+		def initialize(name)
+			if name =~ /^([^0-9]+)([0-9]?.*)/
+				@type = $1.strip
+				@numbers = $2.split('/')
+			else
+				@type = name.strip
+				@numbers = Array.new
+			end
+		end
+
+		def to_s
+			@type + ' ' + @numbers.join('/')
+		end
+
+		def to_csv
+			n = @numbers.dup
+			while n.length < MAX_ARGS do
+				n.unshift('-')
+			end
+			[ @type, n ].join(',')
+		end
+	end
+
+	class Peer
+		attr_reader :sw, :port
+
+		def initialize(sw, portname)
+			@sw = sw
+			@port = portname
+		end
+
+		def has_backlink?
+			return @sw.ports.exists?(@port)
+		end
+
+		def _to_ascii(sep)
+			return "#{@sw.name}#{sep}#{@port}"
+		end
+
+		def to_s
+			_to_ascii(' ')
+		end
+
+		def to_csv
+			_to_ascii(',')
+		end
+	end
+
+	class Peers < Array
+		def add(sw, portname)
+			push(Peer.new(sw, portname))
+		end
+	end
+
+	class Port
+		attr_reader :name, :peers
+		attr_accessor :up
+
+		def initialize(name, model, type, speed, duplex)
+			@name = PortName.new(name)
+			@model = model
+			@type = type_name(type)
+			@speed = speed
+			@duplex = duplex
+			@peers = Peers.new
+			@up = false
+		end
+
+		def type_name(type)
+			type = $1 if type =~ %r{10/100/(1000BaseT).?}
+			type = $1 if type =~ %r{10/(100BaseTX)}
+			type = '1000BaseT' if type =~ %r{10/100/1000-T.?}
+			type = $1 if type =~ /^(.*) SFP/
+			type = 'none' if type =~ /^Not? .*/
+			return type
+		end
+
+		def dump(p)
+			up = @up? '*' : ' '
+			s = sprintf "#{p}#{up}#{@name.to_s} #{@model} #{@type} "
+			print s
+			indent = 0
+			@peers.each { |peer|
+				l = peer.has_backlink? ? '<->' : '->'
+				printf "% *s#{l} #{peer.to_s}\n", indent, ''
+				indent = s.length
+			}
+			puts '' if @peers.length == 0
+		end
+
+		def dump_csv(p)
+			up = @up? '*' : ' '
+			printf "#{p},#{up},#{@name.to_csv},#{@type}"
+			@peers.each { |peer|
+				printf ",#{peer.to_csv}"
+			}
+			puts ''
+		end
+	end
+
+	class Ports
+		def initialize
+			@hash = Hash.new
+			@list = Array.new
+		end
+
+		def add(name, model, type, speed, duplex)
+			port = Port.new(name, model, type, speed, duplex)
+			@list << @hash[port.name.to_s] = port
+		end
+
+		def key(name)
+			PortName.new(name).to_s
+		end
+
+		def [](name)
+			return @hash[key(name)]
+		end
+
+		def exists?(name)
+			return @hash.key?(key(name))
+		end
+
+		def length
+			return @list.length
+		end
+
+		def each
+			@list.each { |p| yield p }
+		end
+	end
+
+	attr_reader :name, :type, :ports, :ia
+	attr_accessor :platform, :firmware, :time
+
+	@@retrieve_all = false
+	@@db = Hash.new
+	@@unretrieved = OnceQueue.new
+	@@warn = Array.new
+
+	def initialize(name, type, ia, retrieve = true)
+		name_set(name)
+		@type = type
+		@ports = Ports.new
+		@retrieve = retrieve
+		@cli = nil
+		ip_address_set(ia)
+
+		return self
+	end
+
+	def name_set(name)
+		raise "Already name is set: #{@name}" if @name
+		@name = name
+		@@db[name] = self if name
+	end
+
+	def ip_address_set(ia)
+		return if ! ia
+		return if @ia
+		@ia = ia
+		case @type
+		when Type::ROUTER, Type::SWITCH
+			@@unretrieved.enqueue(self) if @retrieve
+		end
+	end
+
+	def login
+		return if @cli
+		@cli = CLI.new(@name, @ia)
+		@cli.login
+		name_set(@cli.name) if ! @name
+		#
+		# retrieve interfaces because many commands require
+		# interface name.
+		#
+		interface_gets
+	end
+
+	def logout
+		return if ! @cli
+		@cli.logout
+		@cli = nil
+	end
+
+	def cmd(*argv)
+		@cli.cmd(*argv)
+	end
+
+	def configure
+		@cli.configure
+	end
+
+	def unconfigure
+		@cli.unconfigure
+	end
+
+	def exec(name, *argv)
+		@cli.send(name, *argv)
+	end
+	private :exec
+
+	def maker
+		@cli.maker
+	end
+
+	def maker_to_s
+		@cli.maker_to_s
+	end
+
+	def product
+		@cli.product
+	end
+
+	def prompt
+		@cli.prompt
+	end
+
+	def syslog(*arg)
+		exec(__method__, *arg)
+	end
+
+	def route_gets(ia)
+		exec(__method__, ia)
+	end
+
+	def vrf_gets
+		exec(__method__)
+	end
+
+	def arp_resolve(ia, vrf)
+		exec(__method__, ia, vrf)
+	end
+
+	def mac_address_table_get(ma, vlan)
+		exec(__method__, self, ma, vlan)
+	end
+
+	def interface_gets
+		raise "ERROR: cannot get interfaces twice" if @interface_got
+		@interface_got = true
+		exec(__method__, self)
+	end
+
+	def interface_name(name)
+		exec(__method__, self, name)
+	end
+
+	def interface_name_cli(name)
+		exec(__method__, name)
+	end
+
+	def interface_shutdown(port)
+		exec(__method__, port)
+	end
+
+	def interface_noshutdown(port)
+		exec(__method__, port)
+	end
+
+	def acl_exists?(*arg)
+		exec(__method__, *arg)
+	end
+
+	def acl_add(*arg)
+		exec(__method__, *arg)
+	end
+
+	def acl_delete(*arg)
+		exec(__method__, *arg)
+	end
+
+	def neighbor_gets(*arg)
+		exec(__method__, self, *arg)
+	end
+
+	def macaddr_resolve(ia)
+		vrf_gets.each do |name, vrf|
+			arp = arp_resolve(ia, vrf)
+			next if ! arp
+			#
+			# bark here if static ARP entry is found because
+			# static ARP entry may be for this system itself.
+			#
+			if arp.static
+				raise "ERROR: Static MAC address " +
+				    "found for #{ia}"
+			end
+			return arp.ma, vrf, arp.interface
+		end
+		raise "No MAC address found for #{ia}"
+	end
+
+	def self.get(name, type, platform = nil, firmware = nil, time = nil,
+	    ia = nil)
+		# XXX should lock
+		if @@db.key?(name)
+			sw = @@db[name]
+			sw.platform = platform if sw.platform == nil
+			sw.firmware = firmware if sw.firmware == nil
+			sw.time = time if sw.time == nil
+			sw.ip_address_set(ia)
+		else
+			sw = Switch.new(name, type, ia, @@retrieve_all)
+		end
+		return sw
+	end
+
+	def self.retrieve
+		raise(ArgumentError, 'no user defined') if USERS.empty?
+		raise(ArgumentError, 'no password defined') if PASSWORDS.empty?
+		if ENABLES.empty?
+			raise(ArgumentError, 'no enable password defined')
+		end
+
+		thread_concurrency = 64
+		for i in 1..thread_concurrency do
+			Thread.new do
+				while true
+					sw = @@unretrieved.dequeue
+					begin
+						yield sw
+						sw.neighbor_gets
+					rescue Errno::ECONNREFUSED,
+					    Errno::ECONNRESET,
+					    Errno::EPERM,
+					    Timeout::Error => e
+						msg = "WARNING: cannot " +
+						    "retrieve #{sw.name} " +
+						    "(#{sw.ia}): #{e}"
+						puts msg
+						@@warn.push(msg)
+						@@unretrieved.error
+					rescue => e
+						msg = "WARNING: #{sw.name} " +
+						    "(#{sw.ia}): #{e}"
+						puts msg
+						@@warn.push(msg)
+					ensure
+						@@unretrieved.done(sw)
+					end
+				end
+			end
+		end
+		@@unretrieved.wait_all
+		puts 'Finished!!'
+		puts "Total: #{@@unretrieved.total}, Error: #{@@unretrieved.errors}"
+	end
+
+	def self.set_retrieve_all
+		@@retrieve_all = true
+	end
+
+	def each_peer
+		@ports.each { |p| p.peers.each { |peer| yield peer } }
+	end
+
+	def if_dump
+		puts "#{@name}: #{@platform}, #{@time}, #{@ia.to_s}"
+		@ports.each { |p| p.dump('  ') }
+	end
+
+	def if_dump_csv
+		@ports.each { |p| p.dump_csv(@ia.to_s + ',' + @name) }
+	end
+
+	def config_get
+		@config = @cli.config_get
+	end
+
+	def config_dump(dir = 'conf')
+		begin
+			Dir.mkdir(dir)
+		rescue Errno::EEXIST
+		end
+		path = "#{dir}/#{@name}-#{@ia}.conf"
+		f = File.open(path, 'w')
+		f.puts @config
+		f.close
+	end
+
+	def self.warn
+		@@warn.each { |w| puts w }
+	end
+end