net-netconf 0.4.0

data/lib/net/netconf/jnpr/rpc.rb

@@ -0,0 +1,162 @@
+## -----------------------------------------------------------------------
+## This file contains the Junos specific RPC methods that are generated 
+## specifically and different as generated by the Netconf::RPC::Builder 
+## module.  These are specifically the following:
+##
+##   get_configuration      - alternative NETCONF: 'get-config'
+##   load_configuration     - alternative NETCONF: 'edit-config'
+##   lock_configuration     - alternative NETCONF: 'lock'
+##   commit_configuration   - alternative NETCONF: 'commit'
+##
+## note: unlock_configuration is not included in this file since
+##       the Netconf::RPC::Builder works "as-is" in this case
+## -----------------------------------------------------------------------
+
+module Netconf
+  module RPC
+    module Junos            
+      
+      def lock_configuration
+        lock( 'candidate' )
+      end      
+      
+      def check_configuration
+        validate( 'candidate' )
+      end            
+      
+      def commit_configuration( params = nil, attrs = nil )
+        rpc = Netconf::RPC::Builder.commit_configuration( params, attrs )
+        Netconf::RPC.set_exception( rpc, Netconf::CommitError )
+        @trans.rpc_exec( rpc )   
+      end
+
+      def get_configuration( *args )
+              
+        filter = nil
+        
+        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
+          end
+        end
+
+        rpc = Nokogiri::XML('<rpc><get-configuration/></rpc>').root
+        Netconf::RPC.add_attributes( rpc.first_element_child, attrs ) if attrs            
+        
+        if block_given?
+          Nokogiri::XML::Builder.with(rpc.at( 'get-configuration' )){ |xml|
+            xml.configuration {
+              yield( xml )
+          }}
+        elsif filter
+          # filter must have toplevel = <configuration>
+          rpc.first_element_child << filter.dup   # *MUST* use the .dup so we don't disrupt the original filter
+        end
+               
+        @trans.rpc_exec( rpc )
+      end
+      
+      def load_configuration( *args )
+                
+        config = nil
+        
+        # default format is XML
+        attrs = { :format => 'xml' }
+                
+        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 attrs.merge! arg
+          when 'Array' then config = arg.join("\n")
+          when 'String' then config = arg
+          end
+        end
+        
+        case attrs[:format]
+        when 'set'
+          toplevel = 'configuration-set'
+          attrs[:format] = 'text'
+          attrs[:action] = 'set'          
+        when 'text'
+          toplevel = 'configuration-text'          
+        when 'xml'
+          toplevel = 'configuration'          
+        end                        
+        
+        rpc = Nokogiri::XML('<rpc><load-configuration/></rpc>').root
+        ld_cfg = rpc.first_element_child
+        Netconf::RPC.add_attributes( ld_cfg, attrs ) if attrs   
+        
+        if block_given?
+          if attrs[:format] == 'xml'
+            Nokogiri::XML::Builder.with( ld_cfg ){ |xml|
+              xml.send( toplevel ) {
+                yield( xml )
+            }} 
+          else
+            config = yield  # returns String | Array(of stringable)            
+            config = config.join("\n") if config.class == Array  
+          end
+        end
+        
+        if config
+          if attrs[:format] == 'xml'
+            # config assumes toplevel = <configuration> given            
+            ld_cfg << config.dup        # duplicate the config so as to not distrupt it            
+          else
+            # config is stringy, so just add it as the text node            
+            c_node = Nokogiri::XML::Node.new( toplevel, rpc )            
+            c_node.content = config
+            ld_cfg << c_node            
+          end
+        end
+                                           
+        # set a specific exception class on this RPC so it can be
+        # properlly handled by the calling enviornment
+        
+        Netconf::RPC::set_exception( rpc, Netconf::EditError )    
+        @trans.rpc_exec( rpc )
+      end # load_configuration
+      
+      def command( cmd_str, attrs = nil )
+        rpc = Nokogiri::XML("<rpc><command>#{cmd_str}</command></rpc>").root
+        Netconf::RPC.add_attributes( rpc.at('command'), attrs ) if attrs           
+        @trans.rpc_exec( rpc )
+      end
+      
+      ## contributed by 'dgjnpr'
+      def request_pfe_execute( params = nil )
+        raise ArgumentError, 'Manditorary argument :target missing' unless params[:target]
+        raise ArgumentError, 'Manditorary argument :command missing' unless params[:command]
+
+        rpc_nx = Nokogiri::XML::Builder.new { |xml|
+          xml.rpc {
+            xml.send( 'request-pfe-execute' ) {
+              xml.send( 'target', params[:target] )
+              if params[:command].class.to_s =~ /^Array/
+                params[:command].each { |cmd|
+                  xml.send( 'command', cmd )
+                }
+              elsif params[:command].class.to_s =~ /^String/
+                xml.send( 'command', params[:command] )
+              end
+            }
+          }
+        }
+        @trans.rpc_exec( rpc_nx )
+      end
+            
+    end # module: JUNOS    
+  end # module: RPC
+end # module: Netconf

data/lib/net/netconf/jnpr/serial.rb

@@ -0,0 +1,15 @@
+require 'net/netconf'
+require 'net/netconf/serial'
+require 'net/netconf/jnpr'
+
+module Netconf
+  module Junos    
+    module TransSerial      
+      def trans_start_netconf( last_console )
+        last_console.match(/[^%]\s+$/)
+        netconf_cmd = ($1 == '%') ? Netconf::Junos::NETCONF_SHELL : Netconf::Junos::NETCONF_CLI
+        puts netconf_cmd
+      end      
+    end      
+  end
+end

data/lib/net/netconf/jnpr/ssh.rb

@@ -0,0 +1,27 @@
+require 'net/netconf'
+require 'net/netconf/jnpr'
+
+module Netconf
+  module Junos  
+    module TransSSH
+    
+      ##
+      ## this is used to handle the case where NETCONF (port 830) is disabled.  We can still access
+      ## the NETCONF subsystem from the CLI using a hidden command 'netconf'
+      ##
+      
+      def trans_on_connect_refused( start_args )        
+        start_args[:port] = 22      
+        @trans[:conn] = Net::SSH.start( @args[:target], @args[:username], start_args )
+        do_once = true
+        @trans[:conn].exec( NETCONF_CLI ) do |chan, success|        
+          @trans[:chan] = chan
+          do_once = false
+        end
+        @trans[:conn].loop { do_once }   
+        @trans[:chan]
+      end
+      
+    end
+  end  
+end    

data/lib/net/netconf/jnpr/telnet.rb

@@ -0,0 +1,23 @@
+require 'net/netconf'
+require 'net/netconf/telnet'
+require 'net/netconf/jnpr'
+
+module Netconf
+  module Junos  
+    module TransTelnet
+      
+      def trans_login
+        l_rsp = @trans.login( @args[:username], @args[:password] )
+        # @@@/JLS: need to rescue the timeout ... ???      
+        l_rsp.match("([>%])\s+$")
+        @exec_netconf = ($1 == '%') ? Netconf::Junos::NETCONF_SHELL : Netconf::Junos::NETCONF_CLI
+      end
+      
+      def trans_start_netconf
+        @trans.puts @exec_netconf
+      end
+      
+    end
+  end  
+end    
+

data/lib/net/netconf/rpc.rb

@@ -0,0 +1,71 @@
+require 'net/netconf/rpc_std'
+
+module Netconf  
+  module RPC    
+    
+    def RPC.add_attributes( ele_nx, attr_h )
+      attr_h.each{ |k,v| ele_nx[k] = v }      
+    end
+    
+    def RPC.set_exception( rpc_nx, exception )
+      rpc_nx.instance_variable_set(:@netconf_exception, exception )
+    end
+    
+    def RPC.get_exception( rpc_nx )
+      rpc_nx.instance_variable_get(:@netconf_exception) || Netconf::RpcError
+    end
+    
+    module Builder      
+      # autogenerate an <rpc>, converting underscores (_)
+      # to hyphens (-) along the way ...
+      
+      def Builder.method_missing( method, params = nil, attrs = nil )    
+        
+        rpc_name = method.to_s.tr('_','-').to_sym        
+
+        if params
+          # build the XML starting at <rpc>, envelope the <method> toplevel element,
+          # and then create name/value elements for each of the additional params.  An element
+          # without a value should simply be set to true          
+          rpc_nx = Nokogiri::XML::Builder.new { |xml|
+            xml.rpc { xml.send( rpc_name ) {
+              params.each{ |k,v|
+                sym = k.to_s.tr('_','-').to_sym
+                xml.send(sym, (v==true) ? nil : v )
+              }
+            }}
+          }.doc.root
+        else
+          # -- no params 
+          rpc_nx = Nokogiri::XML("<rpc><#{rpc_name}/></rpc>").root
+        end
+        
+        # if a block is given it is used to set the attributes of the toplevel element         
+        RPC.add_attributes( rpc_nx.at( rpc_name ), attrs ) if attrs      
+        
+        # return the rpc command
+        rpc_nx               
+      end # def: method-missing?            
+      
+    end # module: Builder      
+    
+    class Executor
+      include Netconf::RPC::Standard
+      
+      def initialize( trans, os_type )
+        @trans = trans
+        begin  
+          extend Netconf::RPC::const_get( os_type )                
+        rescue NameError
+          # no extensions available ...
+        end        
+      end
+      
+      def method_missing( method, params = nil, attrs = nil )
+        @trans.rpc_exec( Netconf::RPC::Builder.send( method, params, attrs ))
+      end        
+    end # class: Executor
+    
+  end # module: RPC
+end # module: Netconf
+      

data/lib/net/netconf/rpc_std.rb

@@ -0,0 +1,133 @@
+module Netconf  
+  module RPC
+    
+    MSG_END = "]]>]]>"
+    MSG_END_RE = /\]\]>\]\]>[\r\n]*$/
+    MSG_CLOSE_SESSION = '<rpc><close-session/></rpc>'       
+    MSG_HELLO = <<-EOM
+<hello xmlns="urn:ietf:params:xml:ns:netconf:base:1.0">
+  <capabilities>
+    <capability>urn:ietf:params:netconf:base:1.0</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,135 @@
+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::const_get( os_type )::TransSerial        
+      
+      @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_receive_hello
+      hello_str = trans_receive()
+      so_xml = hello_str.index("\n") + 1
+      hello_str.slice!(0, so_xml)
+      hello_str
+    end
+    
+    def trans_send_hello
+      nil
+    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
+      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 
+    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