netconf 0.2.1

data/lib/net/netconf/rpc_std.rb

@@ -0,0 +1,137 @@
+module Netconf  
+  module RPC
+    
+    MSG_END = "]]>]]>"
+    MSG_END_RE = /\]\]>\]\]>[\r\n]*$/
+    MSG_CLOSE_SESSION = '<rpc><close-session/></rpc>'       
+    MSG_HELLO = <<-EOM
+<hello>
+  <capabilities>
+    <capability>urn:ietf:params:xml:ns:netconf:base:1.0</capability>
+    <capability>urn:ietf:params:xml:ns:netconf:base:1.0#candidate</capability>
+    <capability>urn:ietf:params:xml:ns:netconf:base:1.0#confirmed-commit</capability>
+    <capability>urn:ietf:params:xml:ns:netconf:base:1.0#validate</capability>
+    <capability>urn:ietf:params:xml:ns:netconf:base:1.0#url?protocol=http,ftp,file</capability>
+  </capabilities>
+</hello>    
+EOM
+
+  module Standard
+    
+    def lock( target )      
+      rpc = Nokogiri::XML( "<rpc><lock><target><#{target}/></target></lock></rpc>" ).root
+      Netconf::RPC.set_exception( rpc, Netconf::LockError )
+      @trans.rpc_exec( rpc )      
+    end
+    
+    def unlock( target )
+      rpc = Nokogiri::XML( "<rpc><unlock><target><#{target}/></target></unlock></rpc>" ).root
+      @trans.rpc_exec( rpc )          
+    end
+    
+    def validate( source )
+      rpc = Nokogiri::XML( "<rpc><validate><source><#{source}/></source></validate></rpc>" ).root
+      Netconf::RPC.set_exception( rpc, Netconf::ValidateError )      
+      @trans.rpc_exec( rpc )          
+    end
+    
+    def commit
+      rpc = Nokogiri::XML( "<rpc><commit/></rpc>" ).root
+      Netconf::RPC.set_exception( rpc, Netconf::CommitError )      
+      @trans.rpc_exec( rpc )                
+    end
+    
+    def delete_config( target )
+      rpc = Nokogiri::XML( "<rpc><delete-config><target><#{target}/></target></delete-config></rpc>" ).root
+      @trans.rpc_exec( rpc )          
+    end
+    
+    def get_config( *args ) # :yeield: filter_builder
+      
+      source = 'running'    # default source is 'running'
+      filter = nil          # no filter by default
+      
+      while arg = args.shift
+        case arg.class.to_s
+        when /^Nokogiri/ 
+          filter = case arg
+            when Nokogiri::XML::Builder  then arg.doc.root
+            when Nokogiri::XML::Document then arg.root
+            else arg
+            end    
+        when 'Hash' then attrs = arg
+        when 'String' then source = arg
+        end
+      end
+      
+      rpc = Nokogiri::XML("<rpc><get-config><source><#{source}/></source></get-config></rpc>").root
+      
+      if block_given?
+        Nokogiri::XML::Builder.with( rpc.at( 'get-config' )){ |xml|
+          xml.filter( :type => 'subtree' ) {
+            yield( xml )
+          }
+        }
+      end
+      
+      if filter
+        f_node = Nokogiri::XML::Node.new( 'filter', rpc )
+        f_node['type'] = 'subtree'
+        f_node << filter.dup   # copy filter, don't mess with the original since it may be re-used
+        rpc.at('get-config') <<  f_node
+      end             
+            
+      @trans.rpc_exec( rpc )      
+    end
+
+    def edit_config( *args ) # :yeield: config_builder
+      
+      toplevel = 'config'   # default toplevel config element
+      target = 'candidate'  # default source is 'candidate'  @@@/JLS hack; need to fix this
+      config = nil
+      options = {}
+      
+      while arg = args.shift
+        case arg.class.to_s
+        when /^Nokogiri/ 
+          config = case arg
+            when Nokogiri::XML::Builder  then arg.doc.root
+            when Nokogiri::XML::Document then arg.root
+            else arg
+            end    
+        when 'Hash' then options = arg
+        when 'String' then target = arg
+        end
+      end
+      
+      toplevel = options[:toplevel] if options[:toplevel]
+
+      rpc_str = <<-EO_RPC
+<rpc>
+<edit-config>
+   <target><#{target}/></target>
+   <#{toplevel}/>
+</edit-config>
+</rpc>
+EO_RPC
+
+      rpc = Nokogiri::XML( rpc_str ).root
+      
+      if block_given?
+        Nokogiri::XML::Builder.with(rpc.at( toplevel )){ |xml|
+          yield( xml )
+        }
+      elsif config
+        rpc.at( toplevel ) << config.dup
+      else
+        raise ArgumentError, "You must specify edit-config data!"    
+      end                    
+      
+      Netconf::RPC.set_exception( rpc, Netconf::EditError )    
+      @trans.rpc_exec( rpc )      
+    end    
+        
+  end
+
+  end # module: RPC  
+end # module: Netconf

data/lib/net/netconf/serial.rb

@@ -0,0 +1,132 @@
+require 'serialport'
+
+module Netconf
+  
+  class Serial < Netconf::Transport
+    
+    DEFAULT_BAUD = 9600
+    DEFAULT_DATABITS = 8
+    DEFAULT_STOPBITS = 1
+    DEFAULT_PARITY = SerialPort::NONE
+    DEFAULT_RDBLKSZ = (1024*1024)
+    
+    attr_reader :args
+        
+    def initialize( args_h, &block )
+      os_type = args_h[:os_type] || Netconf::DEFAULT_OS_TYPE
+      
+      raise Netconf::InitError, "Missing 'port' param" unless args_h[:port]
+      raise Netconf::InitError, "Missing 'username' param" unless args_h[:username]
+      
+      @args = args_h.clone
+      @args[:prompt] ||= /([%>])\s+$/
+        
+      # extend this instance with the capabilities of the specific console
+      # type; it needs to define #trans_start_netconf session
+      # this must be provided! if the caller does not, this will 
+      # throw a NameError exception.
+      
+      extend Netconf::TransSerial::const_get( os_type )        
+      
+      @trans_timeout = @args[:timeout] || Netconf::DEFAULT_TIMEOUT
+      @trans_waitio = @args[:waitio] || Netconf::DEFAULT_WAITIO
+
+      super( &block )      
+    end      
+    
+    def login
+      
+      begin
+        puts
+        waitfor(/ogin:/)
+      rescue Timeout::Error
+        puts
+        waitfor(/ogin:/)
+      end
+      
+      puts @args[:username]
+      
+      waitfor(/assword:/)
+      puts @args[:password]
+      
+      waitfor( @args[:prompt] )
+    end
+    
+    def trans_open # :yield: self
+      
+      baud = @args[:speed] || DEFAULT_BAUD
+      data_bits = @args[:bits] || DEFAULT_DATABITS
+      stop_bits = @args[:stop] || DEFAULT_STOPBITS
+      parity = @args[:parity] || DEFAULT_PARITY
+      
+      @trans = SerialPort.new( @args[:port], baud, data_bits, stop_bits, parity )            
+            
+      got = login()      
+      yield self if block_given?      
+      trans_start_netconf( got )      
+      
+      self
+    end
+    
+    def trans_hello
+      hello_str = trans_receive()
+      so_xml = hello_str.index("\n") + 1
+      hello_str.slice!(0, so_xml)
+      hello_str
+    end
+    
+    def trans_close
+      @trans.write Netconf::RPC::MSG_CLOSE_SESSION
+      @trans.close
+    end
+    
+    def trans_send( cmd_str )
+      @trans.write( cmd_str )
+      @trans.fsync          
+    end
+    
+    def trans_receive
+      got = waitfor( Netconf::RPC::MSG_END_RE )
+      msg_end = got.rindex( Netconf::RPC::MSG_END )
+      got[msg_end .. -1] = ''
+      got
+    end
+        
+    def puts( str = nil )
+      @trans.puts str 
+      @trans.fsync          
+    end
+        
+    def waitfor( this_re = nil )      
+      on_re = this_re || @args[:prompt]
+      
+      time_out = @trans_timeout
+      wait_io = @trans_waitio
+
+      time_out = nil if time_out == false
+      done = false
+      rx_buf = ''      
+                  
+      until( rx_buf.match( on_re ) and not IO::select( [@trans], nil, nil, wait_io ) )
+              
+        unless IO::select( [@trans], nil, nil, time_out )
+          raise TimeoutError, "Netconf IO timed out while waiting for more data"
+        end
+      
+        begin                   
+          
+          rx_some = @trans.readpartial( DEFAULT_RDBLKSZ )                         
+          rx_buf += rx_some
+          break if rx_buf.match( on_re )
+          
+        rescue EOFError # End of file reached
+          rx_buf = nil if rx_buf == ''
+          break   # out of outer 'until' loop
+        end        
+        
+      end      
+      rx_buf
+    end     
+    
+  end # class: Serial
+end # module: Netconf

data/lib/net/netconf/ssh.rb

@@ -0,0 +1,77 @@
+require 'net/ssh'
+
+module Netconf      
+  class SSH < Netconf::Transport
+    
+    NETCONF_PORT = 830
+    NETCONF_SUBSYSTEM = 'netconf'    
+    
+    def initialize( args_h, &block )      
+      @args = args_h.clone
+      @trans = Hash.new   
+      
+      super( &block )
+    end
+    
+    def trans_open( &block )
+      # open a connection to the NETCONF subsystem        
+      start_args = Hash.new
+      start_args[:password] ||= @args[:password]
+      start_args[:passphrase] = @args[:passphrase] || nil
+      start_args[:port] = @args[:port] || NETCONF_PORT
+      
+      @trans[:conn] = Net::SSH.start( @args[:target], @args[:username], start_args )     
+      @trans[:chan] = @trans[:conn].open_channel{ |ch| ch.subsystem( NETCONF_SUBSYSTEM ) }      
+    end
+    
+    def trans_close     
+      @trans[:chan].close if @trans[:chan]
+      @trans[:conn].close if @trans[:conn]
+    end
+        
+    def trans_receive
+      @trans[:rx_buf] = ''
+      @trans[:more] = true
+      
+      # collect the response data as it comes back ...
+      # the "on" functions must be set before calling
+      # the #loop method
+      
+      @trans[:chan].on_data do |ch, data|
+        if data.include?( RPC::MSG_END )
+          data.slice!( RPC::MSG_END )
+          @trans[:rx_buf] << data unless data.empty?
+          @trans[:more] = false
+        else
+          @trans[:rx_buf] << data
+        end
+      end
+      
+      # ... if there are errors ... 
+      @trans[:chan].on_extended_data do |ch, type, data|
+        @trans[:rx_err] = data
+        @trans[:more] = false
+      end
+      
+      # the #loop method is what actually performs
+      # ssh event processing ...
+      
+      @trans[:conn].loop { @trans[:more] }        
+      
+      return @trans[:rx_buf]      
+    end
+    
+    def trans_send( cmd_str )
+      @trans[:chan].send_data( cmd_str )                    
+    end
+    
+    # accessor to create an Net::SCP object so the caller can perform
+    # secure-copy operations (see Net::SCP) for details
+    def scp
+      @scp ||= Net::SCP.start( @args[:target], @args[:username], :password => @args[:password] )
+    end
+    
+  end # class: SSH
+end #module: Netconf
+
+require 'net/netconf/ssh'

data/lib/net/netconf/telnet.rb

@@ -0,0 +1,58 @@
+require 'net/telnet'
+
+module Netconf
+  
+  class Telnet < Netconf::Transport
+                
+    def initialize( args, trans_args = nil, &block )
+      os_type = args[:os_type] || Netconf::DEFAULT_OS_TYPE            
+      @args = args.clone
+            
+      # extend this instance with the capabilities of the specific console
+      # type; it needs to define #login and #start_netconf session
+      begin
+        extend Netconf::TransTelnet::const_get( os_type )        
+      rescue NameError
+        # no extensions available ...
+      end     
+      
+      my_trans_args = {}
+      my_trans_args["Host"] = @args[:target]
+      my_trans_args["Port"] = @args[:port] if @args[:port]
+      
+      @trans = Net::Telnet.new( my_trans_args )
+      
+      @trans_timeout = @args[:timeout] || Netconf::DEFAULT_TIMEOUT
+      @trans_waitio = @args[:waitio] || Netconf::DEFAULT_WAITIO      
+     
+      super( &block )      
+    end      
+        
+    def trans_open( &block )
+      trans_login()
+      trans_start_netconf() 
+      self
+    end
+    
+    def trans_hello
+      hello_str = trans_receive()
+      so_xml = hello_str.index("\n") + 1      # skip over the last issued command      
+      hello_str[so_xml .. -1]
+    end
+    
+    def trans_close
+      @trans.write Netconf::RPC::MSG_CLOSE_SESSION
+      @trans.close
+    end
+    
+    def trans_send( cmd_str )
+      @trans.write( cmd_str )
+    end
+    
+    def trans_receive      
+      rsp = @trans.waitfor( Netconf::RPC::MSG_END_RE )
+      rsp.chomp!( Netconf::RPC::MSG_END + "\n" )      
+    end
+    
+  end # class: Serial
+end # module: Netconf

data/lib/net/netconf/transport.rb

@@ -0,0 +1,113 @@
+## -----------------------------------------------------------------------
+## This file contains the Netconf::Transport parent class definition.
+## All other transports, i.e. "ssh", "serial", "telnet" use this parent
+## class to define their transport specific methods:
+##
+##    trans_open: open the transport connection
+##    trans_close: close the transport connection
+##    trans_send: send XML command (String) via transport
+##    trans_receive: receive XML response (String) via transport
+##
+## -----------------------------------------------------------------------
+
+module Netconf
+  class Transport
+    
+    attr_reader :rpc, :state, :session_id, :capabilities
+    attr_writer :timeout, :waitio
+    
+    def initialize( &block ) 
+      
+      @state = :NETCONF_CLOSED
+      @os_type = @args[:os_type] || Netconf::DEFAULT_OS_TYPE
+            
+      @rpc = Netconf::RPC::Executor.new( self, @os_type )
+      
+      if block_given?
+        open( &block = nil )      # do not pass this block to open()
+        yield self
+        close()
+      end
+      
+    end # initialize
+    
+    def open( &block ) # :yield: specialized transport open, generally not used
+      
+      raise Netconf::StateError if @state == :NETCONF_OPEN
+      
+      # block is used to deal with special open processing ...
+      # this is *NOT* the block passed to initialize()
+      raise Netconf::OpenError unless trans_open( &block )      
+      @state = :NETCONF_OPEN            
+      
+      hello_rsp = Nokogiri::XML( trans_hello() )
+      
+      @capabilities = hello_rsp.xpath('//capability').map{ |c| c.text }
+      @session_id = hello_rsp.xpath('//session-id').text            
+      self      
+    end
+    
+    def trans_hello
+      trans_receive()
+    end
+    
+    def has_capability?( capability )
+      @capabilities.select{|c| c.include? capability }.pop
+      # note: the caller could also simply use #grep on @capabilities
+    end
+        
+    def close
+      raise Netconf::StateError unless @state == :NETCONF_OPEN         
+      trans_close()
+      @state = :NETCONF_CLOSED            
+      self
+    end
+    
+    # string in; string out
+    def send_and_receive( cmd_str )
+      trans_send( cmd_str )
+      trans_receive()
+    end
+    
+    def rpc_exec( cmd_nx )
+      raise Netconf::StateError unless @state == :NETCONF_OPEN         
+
+      # send the XML command through the transport and 
+      # receive the response; then covert it to a Nokogiri XML
+      # object so we can process it.
+      
+      rsp_nx = Nokogiri::XML( send_and_receive( cmd_nx.to_xml ))
+      
+      # the following removes only the default namespace (xmlns)
+      # definitions from the document.  This is an alternative
+      # to using #remove_namespaces! which would remove everything
+      # including vendor specific namespaces.  So this approach is a 
+      # nice "compromise" ... just don't know what it does 
+      # performance-wise on large datasets.
+
+      rsp_nx.traverse{ |n| n.namespace = nil }
+      
+      # set the response context to the root node; <rpc-reply>
+      
+      rsp_nx = rsp_nx.root
+            
+      # the <rpc-error> could either be at the toplevel or 
+      # as a child element of toplevel. 
+      
+      if rsp_nx.xpath( "rpc-error|*/rpc-error" )[0]     
+        exception = Netconf::RPC.get_exception( cmd_nx )       
+        raise exception.new( self, cmd_nx, rsp_nx )        
+      end        
+      
+      # return the XML with context at toplevel element; i.e.
+      # after the <rpc-reply> element
+      # @@@/JLS: might this be <ok> ? isn't for Junos, but need to check
+      # @@@/JLS: the generic case.
+      
+      rsp_nx.first_element_child
+      
+    end
+    
+
+  end #--class: Transport  
+end #--module: Netconf