net-netconf 0.4.1 → 0.4.2

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

@@ -3,13 +3,13 @@ require 'net/netconf/serial'
 require 'net/netconf/jnpr'
 
 module Netconf
-  module Junos    
-    module TransSerial      
+  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
   end
 end

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

@@ -2,26 +2,26 @@ require 'net/netconf'
 require 'net/netconf/jnpr'
 
 module Netconf
-  module Junos  
+  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      
+
+      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[:conn].exec( NETCONF_CLI ) do |chan, success|
           @trans[:chan] = chan
           do_once = false
         end
-        @trans[:conn].loop { do_once }   
+        @trans[:conn].loop { do_once }
         @trans[:chan]
       end
-      
+
     end
-  end  
-end    
+  end
+end

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

@@ -3,21 +3,21 @@ require 'net/netconf/telnet'
 require 'net/netconf/jnpr'
 
 module Netconf
-  module Junos  
+  module Junos
     module TransTelnet
-      
+
       def trans_login
         l_rsp = @trans.login( @args[:username], @args[:password] )
-        # @@@/JLS: need to rescue the timeout ... ???      
+        # @@@/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    
+  end
+end
 

data/lib/net/netconf/rpc.rb

@@ -1,32 +1,32 @@
 require 'net/netconf/rpc_std'
 
-module Netconf  
-  module RPC    
-    
+module Netconf
+  module RPC
+
     def RPC.add_attributes( ele_nx, attr_h )
-      attr_h.each{ |k,v| ele_nx[k] = v }      
+      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      
+
+    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        
+
+      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          
+          # 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|
@@ -36,36 +36,36 @@ module Netconf
             }}
           }.doc.root
         else
-          # -- no params 
+          # -- 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      
-        
+
+        # 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      
-    
+        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 )                
+        begin
+          extend Netconf::RPC::const_get( os_type )
         rescue NameError
           # no extensions available ...
-        end        
+        end
       end
-      
+
       def method_missing( method, params = nil, attrs = nil )
         @trans.rpc_exec( Netconf::RPC::Builder.send( method, params, attrs ))
-      end        
+      end
     end # class: Executor
-    
+
   end # module: RPC
 end # module: Netconf
-      
+

data/lib/net/netconf/rpc_std.rb

@@ -13,11 +13,9 @@ module Netconf
 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 )
+      run_valid_or_lock_rpc "<rpc><lock><target><#{target}/></target></lock></rpc>",
+                            Netconf::LockError
     end
 
     def unlock( target )
@@ -26,8 +24,13 @@ EOM
     end
 
     def validate( source )
-      rpc = Nokogiri::XML( "<rpc><validate><source><#{source}/></source></validate></rpc>" ).root
-      Netconf::RPC.set_exception( rpc, Netconf::ValidateError )
+      run_valid_or_lock_rpc "<rpc><validate><source><#{source}/></source></validate></rpc>",
+                            Netconf::ValidateError
+    end
+
+    def run_valid_or_lock_rpc(rpc_string, error_type)
+      rpc = Nokogiri::XML(rpc_string).root
+      Netconf::RPC.set_exception( rpc, error_type )
       @trans.rpc_exec( rpc )
     end
 
@@ -42,11 +45,7 @@ EOM
       @trans.rpc_exec( rpc )
     end
 
-    def get_config( *args ) # :yeield: filter_builder
-
-      source = 'running'    # default source is 'running'
-      filter = nil          # no filter by default
-
+    def process_args(args)
       while arg = args.shift
         case arg.class.to_s
         when /^Nokogiri/
@@ -59,6 +58,14 @@ EOM
         when 'String' then source = arg
         end
       end
+    end
+
+    def get_config( *args ) # :yeield: filter_builder
+
+      source = 'running'    # default source is 'running'
+      filter = nil          # no filter by default
+
+      arg = process_args(args)
 
       rpc = Nokogiri::XML("<rpc><get-config><source><#{source}/></source></get-config></rpc>").root
 
@@ -87,18 +94,7 @@ EOM
       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
+      arg = process_args(args)
 
       toplevel = options[:toplevel] if options[:toplevel]
 

data/lib/net/netconf/serial.rb

@@ -1,41 +1,41 @@
 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 
+      # this must be provided! if the caller does not, this will
       # throw a NameError exception.
-      
-      extend Netconf::const_get( os_type )::TransSerial        
-      
+
+      extend Netconf::const_get( os_type )::TransSerial
+
       @trans_timeout = @args[:timeout] || Netconf::DEFAULT_TIMEOUT
       @trans_waitio = @args[:waitio] || Netconf::DEFAULT_WAITIO
 
-      super( &block )      
-    end      
-    
+      super( &block )
+    end
+
     def login
-      
+
       begin
         puts
         waitfor(/ogin:/)
@@ -43,93 +43,62 @@ module Netconf
         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 )      
-      
+
+      @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
+      Netconf.trans_receive
     end
-        
+
     def puts( str = nil )
-      @trans.puts str 
+      @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     
-    
+
+    def waitfor( this_re = nil )
+      Netconf.waitfor(on_re)
+    end
+
   end # class: Serial
 end # module: Netconf

data/lib/net/netconf/ssh.rb

@@ -1,94 +1,95 @@
 require 'net/ssh'
+require 'net/netconf/ssh'
 
-module Netconf      
+module Netconf
   class SSH < Netconf::Transport
-    
     NETCONF_PORT = 830
-    NETCONF_SUBSYSTEM = 'netconf'    
-    
-    def initialize( args_h, &block )      
+    NETCONF_SUBSYSTEM = 'netconf'
+
+    def initialize(args_h, &block)
       @args = args_h.clone
       @args[:os_type] = args_h[:os_type] || Netconf::DEFAULT_OS_TYPE
-      
+
       # extend this instance with the capabilities of the specific os_type
       begin
-        extend Netconf::const_get( @args[:os_type] )::TransSSH        
+        extend Netconf.const_get(@args[:os_type]).TransSSH
       rescue NameError
         # no extensions available ...
-      end     
-      
-      @trans = Hash.new   
-      super( &block )
+      end
+
+      @trans = {}
+      super(&block)
     end
-    
-    def trans_open( &block )
-      # open a connection to the NETCONF subsystem        
-      start_args = Hash.new
+
+    def trans_open(&block)
+      # open a connection to the NETCONF subsystem
+      start_args = {}
       start_args[:password] ||= @args[:password]
       start_args[:passphrase] = @args[:passphrase] || nil
       start_args[:port] = @args[:port] || NETCONF_PORT
       start_args.merge!(@args[:ssh_args]) if @args[:ssh_args]
-            
+
       begin
-        @trans[:conn] = Net::SSH.start( @args[:target], @args[:username], start_args )     
-        @trans[:chan] = @trans[:conn].open_channel{ |ch| ch.subsystem( NETCONF_SUBSYSTEM ) }
+        @trans[:conn] = Net::SSH.start(@args[:target], @args[:username], start_args)
+        @trans[:chan] = @trans[:conn].open_channel do |ch|
+          ch.subsystem(NETCONF_SUBSYSTEM)
+        end
       rescue Errno::ECONNREFUSED => e
         if self.respond_to? 'trans_on_connect_refused'
-          return trans_on_connect_refused( start_args )
+          return trans_on_connect_refused(start_args)
         end
         return nil
       end
       @trans[:chan]
     end
-    
-    def trans_close     
+
+    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[: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|
+
+      # ... 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]      
+
+      @trans[:conn].loop { @trans[:more] }
+
+      @trans[:rx_buf]
     end
-    
-    def trans_send( cmd_str )
-      @trans[:chan].send_data( cmd_str )  
+
+    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] )
+      @scp ||= Net::SCP.start(@args[:target],
+                              @args[:username],
+                              password: @args[:password])
     end
-    
   end # class: SSH
-end #module: Netconf
-
-require 'net/netconf/ssh'
+end # module: Netconf