Internal/OpenFlow/XORP: lb9a.rb

#!/usr/bin/ruby1.8 -w

###
# lb9a.rb
# libraries that behave as a "wrapper" to XorPlus on the LB9A (Quanta) switch.
# 8/28/11 - added dry-run capability 
# 8/29/11 - string/array processing functions as class extensions; some cleanup of Session class   
###

require 'net/telnet'
require 'singleton'
require 'logger'

LOG = Logger.new(STDOUT)

$portrng = (1..48)  #48 GBe ports on switch
$vlanrng = (1..1024)    #up to 1024 VLAN IDs per switch 


# Deals with telnet session/CLI interactions
class Session

    attr_reader :hname, :port, :dbg

    def initialize(hostname, port = 23, debug = false, dryrun = false)
        @hname = hostname
        @port = port
        @dbg = debug        #verbose mode
        @drun = dryrun      #do not actually send command via serial
    end
    
    # init - initialize telnet session
    def init()
        begin
            if @dbg then LOG.level = Logger::DEBUG else LOG.level = Logger::INFO end
            unless @drun  
                @conn = Net::Telnet::new( "Host" => @hname, "Port" => @port )
                @conn.cmd("configure")  #enter config mode 
                LOG.debug("Session.init: initializing telnet session")
            else
                @conn = nil 
                LOG.debug("Session.init: initializing dry-run")
            end
        rescue Exception => e
            LOG.fatal("Session.init: #{e.class}, #{e.message}")
            raise
        end
    end

private
    # rncmd - send command for each port in iflist, replacing '##' in command with proper port number
    # cannot take commands with a scrolling output buffer (To-do) 
    def rncmd(command, iflist)
        begin
            LOG.debug("Session.range_cmd: command: #{command}")
            LOG.debug("Session.range_cmd: iflist: #{iflist}")
            iflist.map do |iface|
                out = command.gsub(/##/, iface.to_s)
                unless @drun then ret = @conn.cmd(out) else puts "#{out}" end
                LOG.debug("Session.range_cmd: command: #{out}")
                LOG.debug("Session.range_cmd: return: #{ret}")
            end
        rescue Exception => e
            LOG.fatal("Session.rncmd: #{e.class} #{e.message}")     
            raise
        end
    end

public
    # set_iface - sets management interface address
    def set_iface(iface, addr, del = false)
        begin
            if del then dflg = "delete " else dflg = "set " end
            if (iface.match(/eth(0|1)/))&&(addr.match(/\d+\.\d+\.\d+\.\d+\/\d+/))
                out = "#{dflg}interface management-ethernet #{iface} address #{addr}"
                unless @drun
                    @conn.cmd(out) do |ret|
                        LOG.debug("Session.set_iface: return: #{ret}")
                    end
                else
                    puts "#{out}"
                end 
                return true
            else
                puts "\tiface [eth0|eth1] [IP addr/mask]"
                return false
            end
        rescue Exception => e
            LOG.fatal("Session.set_iface: #{e.class} #{e.message}")
            raise
        end
    end

    # set_vlan - sets up a new VLAN 
    # To-do : add multiple VLAN delete facility 
    def set_vlan(id, del = false)
        begin
            if del then dflg = "delete " else dflg = "set " end
            if ($vlanrng.member? id)
                out = "#{dflg}vlans vlan-id #{id}"
                unless @drun
                    @conn.cmd(out) do |ret|
                        LOG.debug("Session.set_vlan: return: #{ret}")
                    end
                else
                    puts "#{out}"
                end
                return true
            else
                puts "\tvlan [VLAN ID]" 
                puts "\tVLAN ID must be value between [1..1024]"
                return false
            end
        rescue  Exception => e
                LOG.fatal("Session.set_vlan: #{e.class} #{e.message}")
            raise
        end
    end

    # set_ports - configurations of various port properties
    def set_ports(ctxt, iflist)
        @vlans = []
        @tflag = false
        @cmd = ' '

        args = ctxt.split(' ')  # args - array containing components of command 
        LOG.debug("Session.set_ports: args: #{args[0]},#{args[1]}")
        
        # assign the proper command to @cmd based on input
        case args[0]
            when "delete"
                @cmd = "delete interface gigabit-ethernet ge-1/1/## family ethernet-switching"
            when "vlan"
                if ($vlanrng.member? args[1].to_i)
                    @cmd = "set interface gigabit-ethernet ge-1/1/## family ethernet-switching native-vlan-id #{args[1]}"
                else
                    puts "\tVLAN ID must be value between [1..1024]"
                end
            when "mode"
                if args[1] == "access"
                    @cmd = "set interface gigabit-ethernet ge-1/1/## family ethernet-switching port-mode access"
                elsif args[1] == "trunk"
                    @tflag = true
                    print "Member VLANs (X,Y,Z...): "
                    @vlans = gets.chomp.split(',')
                    
                    LOG.debug("Session.set_ports: vlans #{@vlans.class}: #{@vlans}")
                    @cmd = "set interface gigabit-ethernet ge-1/1/## family ethernet-switching port-mode trunk"
                else
                    puts "\t#{args[1]}: Unknown port mode"
                end
            else 
                puts "\t#{ctxt}: Unknown command"
        end
        LOG.debug("Session.set_ports: @cmd: #{@cmd}")

        # invoke rncmd with proper command
        if @tflag
            for i in @vlans
                rncmd("set interface gigabit-ethernet ge-1/1/## family ethernet-switching vlan members #{i}",iflist)
            end 
        end

        unless @cmd.empty? 
            rncmd(@cmd, iflist)
            return true
        else
            return false     
        end
    end

    # commit - saves configurations
    def commit()
        puts "saving settings (this may take a while)..."
        unless @drun then @conn.cmd("commit") else puts "commit" end 
        sleep 5
        unless @drun then @conn.cmd("save running-to-startup") else puts "save running-to-startup" end
    end

    # logoff - close connection after exiting enabled mode
    def logoff(saved)
        begin
            unless @drun 
                unless saved then @conn.cmd("exit discard") end
                @conn.cmd("exit")   
                @conn.close
            else
                puts "exit"
            end 
        rescue Exception => e
            LOG.fatal("Session.logoff: #{e.class} #{e.message}") 
            raise
        end
    end

end

# to_rng - flattens nested arrays with ranges e.g. [3..5,20,[13..15]] -> [3,4,5,20,13,14,15] 
class Array
    def to_rng()
        self.map do |x|
            if x.is_a? Range
                x.to_a
            elsif x.is_a? Fixnum
                x 
            elsif x.is_a? Array
                x.to_rng            
            else
                raise "Array.to_rng:#{x}:not Fixnum or Range"
            end
        end.flatten
    end 
end

# to_ra - convers string of numbers and rangesto array with Range and Fixnum objects e.g. "1..3,5" -> [1..3,5]
class String
    def to_ra() 
        self.split(',').map do |x|
            if x.length <= 2
                Integer(x) 
            elsif x.include? ".."
                ends = x.split("..").map{|i| Integer(i)}
                                x = ends[0]..ends[1]
            else
                raise "Sring.to_ra:#{x}:Invalid range string format"
            end
        end
    end
end

=begin  
    # the set_* family of commands without subcontexts follow this pattern... 
    # If functions can be used as input, this is a legitimate template.
    def set_ptype(name, matchstr, cmd, syntax)
        begin
            if (matchstr)
                out = cmd
                unless @drun
                    @conn.cmd(out) do |ret|
                        LOG.debug("Session.#{name}: return: #{ret}")
                    end 
                else
                    puts "#{out}"
                end
            else
                puts "#{syntax}"
            end
        rescue Exception => e
            LOG.fatal("Session.set_iface: #{e.class} #{e.message}")
            raise
        end 
    end
=end