junos-ez-stdlib 0.0.12 → 0.0.15

data/lib/junos-ez/l1_ports.rb

@@ -10,6 +10,8 @@ module Junos::Ez::L1ports
     :duplex,              # [ :auto, :half, :full ]
     :unit_count,          # number of configured units
   ]  
+  
+  IFS_NAME_FILTER = '[fgx]e-*'
 
   def self.Provider( ndev, varsym )            
     newbie = case ndev.fact( :ifd_style )
@@ -47,7 +49,7 @@ class Junos::Ez::L1ports::Provider < Junos::Ez::Provider::Parent
     @ndev.rpc.get_interface_information({
         :media => true,
         :terse => true,
-        :interface_name => '[fgx]e-*'
+        :interface_name => Junos::Ez::L1ports::IFS_NAME_FILTER
     }).xpath('physical-interface/name').collect do |ifs|
       ifs.text.strip
     end
@@ -56,24 +58,62 @@ class Junos::Ez::L1ports::Provider < Junos::Ez::Provider::Parent
   def build_catalog
     @catalog = {}
     
-    @ndev.rpc.get_configuration{|xml|
-      xml.interfaces {
-        list!.each do |ifs|
+    # we could have a large list of interfaces, so
+    # we need to break this up into individual "gets"
+    
+    list!.each do |ifs_name|
+      @ndev.rpc.get_configuration{ |xml|
+        xml.interfaces {
           xml.interface {
-            xml.name ifs
+            xml.name ifs_name
             xml_read_filter( xml )
           }
-        end
-      }
-    }.xpath('interfaces/interface').each do |ifs_xml|
-      ifs_name = ifs_xml.xpath('name').text
-      @catalog[ifs_name] = {}
-      xml_read_parser( ifs_xml, @catalog[ifs_name] )
+        }
+      }.xpath('interfaces/interface').each do |ifs_xml|
+        @catalog[ifs_name] = {}
+        xml_read_parser( ifs_xml, @catalog[ifs_name] )
+      end
     end
     
     return @catalog
   end
   
+  ### ---------------------------------------------------------------
+  ###  Resource methods
+  ### ---------------------------------------------------------------  
+  
+  ## returns a Hash of status information, from "show interface ..."
+  ## basic information, not absolutely everything.  but if a 
+  ## block is given, then pass the XML to the block.
+  
+  def status
+    
+    got = @ndev.rpc.get_interface_information(:interface_name => @name, :media => true )
+    phy = got.xpath('physical-interface')[0]
+    return nil unless phy
+    
+    ret_h = {}
+    ret_h[:macaddr] = phy.xpath('current-physical-address').text.strip 
+    xml_when_item(phy.xpath('description')){|i| ret_h[:description] = i.text.strip }
+    ret_h[:oper_status] = phy.xpath('oper-status').text.strip
+    ret_h[:admin_status] = phy.xpath('admin-status').text.strip
+    ret_h[:mtu] = phy.xpath('mtu').text.to_i
+    ret_h[:speed] = {:admin => phy.xpath('speed').text.strip }
+    ret_h[:duplex] = {:admin => phy.xpath('duplex').text.strip }
+    ret_h[:autoneg] = phy.xpath('if-auto-negotiation').text.strip 
+    
+    if ret_h[:autoneg] == "enabled"
+      autoneg = phy.xpath('ethernet-autonegotiation')[0]
+      ret_h[:speed][:oper] = autoneg.xpath('link-partner-speed').text.strip
+      ret_h[:duplex][:oper] = autoneg.xpath('link-partner-duplexity').text.strip
+    end
+    
+    # if a block is given, then it means the caller wants to process the XML data.
+    yield( phy ) if block_given?
+    
+    ret_h
+  end
+  
 end  
 
 require 'junos-ez/l1_ports/switch'

data/lib/junos-ez/l2_ports.rb

@@ -6,7 +6,7 @@ module Junos::Ez::L2ports
   PROPERTIES = [ 
     :description,           # String | nil
     :untagged_vlan,         # String | nil
-    :tagged_vlans,          # Array of String | nil
+    :tagged_vlans,          # Set of String | nil
     :vlan_tagging           # true | false
   ]  
 

data/lib/junos-ez/l2_ports/vlan.rb

@@ -52,27 +52,56 @@ class Junos::Ez::L2ports::Provider::VLAN < Junos::Ez::L2ports::Provider
 
     f_eth = as_xml.xpath('family/ethernet-switching')        
     as_hash[:vlan_tagging] = f_eth.xpath('port-mode').text.chomp == 'trunk' 
-
+    
+    # obtain a copy of the running state, this is needed in case the config
+    # is located under the [edit vlans] stanza vs. [edit interfaces]
+    
+    ifs_name = @name || as_xml.xpath('ancestor::interface/name').text.strip
+    eth_port_vlans = _get_eth_port_vlans_h( ifs_name )
+    @under_vlans = []
+    
     # --- access port        
+    
     if as_hash[:vlan_tagging] == false
-      xml_when_item(f_eth.xpath('vlan/members')){|i| as_hash[:untagged_vlan] = i.text.chomp }
+      xml_when_item(f_eth.xpath('vlan/members')){ |i| as_hash[:untagged_vlan] = i.text.chomp }
+      unless as_hash[:untagged_vlan]
+        as_hash[:untagged_vlan] = eth_port_vlans[:untagged]
+        @under_vlans << eth_port_vlans[:untagged]
+      end
       return
     end
     
     # --- trunk port    
+    
     xml_when_item(f_eth.xpath('native-vlan-id')){|i| as_hash[:untagged_vlan] = i.text.chomp }
-    as_hash[:tagged_vlans] = f_eth.xpath('vlan/members').collect { |v| v.text.chomp }    
+    as_hash[:untagged_vlan] ||= eth_port_vlans[:untagged]    
+    as_hash[:tagged_vlans] = f_eth.xpath('vlan/members').collect { |v| v.text.chomp }.to_set   
+    (eth_port_vlans[:tagged] - as_hash[:tagged_vlans]).each do |vlan|
+      as_hash[:tagged_vlans] << vlan
+      @under_vlans << vlan
+    end
+    
   end
     
+  ### ---------------------------------------------------------------
+  ### XML on_create, on_delete handlers
+  ### ---------------------------------------------------------------   
+  
+  ## overload the xml_on_delete method since we may need
+  ## to do some cleanup work in the [edit vlans] stanza
+  
+  def xml_on_delete( xml )
+    return unless @under_vlans
+    return if @under_vlans.empty?
+    
+    _xml_rm_under_vlans( xml, @under_vlans )
+  end   
+  
   ### ---------------------------------------------------------------
   ### XML property writers
   ### ---------------------------------------------------------------    
   
-  ## overload the xml_build_change method so we can 'copy-thru'
-  ## some of the has -> should values.  this way we don't need
-  ## to munge all of the state-transition code.
-  
-  def xml_build_at_here( xml )
+  def xml_at_here( xml )
     xml.family {
       xml.send(:'ethernet-switching') {
         return xml
@@ -80,11 +109,16 @@ class Junos::Ez::L2ports::Provider::VLAN < Junos::Ez::L2ports::Provider
     }
   end
   
-  def xml_build_change( xml_at_here = nil )
-    @should[:untagged_vlan] ||= @has[:untagged_vlan]    
-    super xml_build_at_here( xml_at_top )
-  end
-     
+  def xml_build_change( nop = nil )
+    @under_vlans ||= []       # handles case for create'd port
+    
+    if mode_changed?
+      @should[:untagged_vlan] ||= @has[:untagged_vlan]    
+    end
+    
+    super xml_at_here( xml_at_top )
+  end  
+
   ## ----------------------------------------------------------------
   ## :description
   ## ----------------------------------------------------------------
@@ -110,6 +144,7 @@ class Junos::Ez::L2ports::Provider::VLAN < Junos::Ez::L2ports::Provider
     # when the vlan_tagging value changes then this method
     # will trigger updates to the untagged_vlan and tagged_vlans
     # resource values as well.
+    # !!! DO NOT SWAP THIS ORDER untagged processing *MUST* BE FIRST!
     
     upd_untagged_vlan( xml )
     upd_tagged_vlans( xml ) 
@@ -129,20 +164,23 @@ class Junos::Ez::L2ports::Provider::VLAN < Junos::Ez::L2ports::Provider
   def upd_tagged_vlans( xml )        
     return false unless should_trunk?
     
-    v_should = @should[:tagged_vlans] || []
-    
-    if v_should.empty?
-      xml.vlan Netconf::JunosConfig::DELETE
-      return true
-   end
-    
-    v_has = @has[:tagged_vlans] || []    
-    v_has = v_has.map(&:to_s)    
-    v_should = v_should.map(&:to_s)    
+    @should[:tagged_vlans] = @should[:tagged_vlans].to_set if @should[:tagged_vlans].kind_of? Array
+    @has[:tagged_vlans] = @has[:tagged_vlans].to_set if @has[:tagged_vlans].kind_of? Array    
+
+    v_should = @should[:tagged_vlans] || Set.new    
+    v_has = @has[:tagged_vlans] || Set.new    
     
     del = v_has - v_should
     add = v_should - v_has 
-    
+
+    del_under_vlans = del & @under_vlans    
+
+    unless del_under_vlans.empty?
+      del = del ^ @under_vlans
+      _xml_rm_under_vlans( xml, del_under_vlans )
+      @under_vlans = []
+    end
+
     if add or del
       xml.vlan {
         del.each { |v| xml.members v, Netconf::JunosConfig::DELETE }
@@ -226,46 +264,46 @@ class Junos::Ez::L2ports::Provider::VLAN
   ### -------------------------------------------------------------
   
   def self.ac_ac_nountg( this, xml )
-    xml.vlan Netconf::JunosConfig::DELETE
+    this._xml_rm_ac_untagged_vlan( xml )
   end
   
   def self.ac_tr_nountg( this, xml )      
-    unless (untg_vlan = this.has[:tagged_vlans]).nil?
-      xml.vlan {
-        xml.members untg_vlan, Netconf::JunosConfig::DELETE
-      }              
+    unless (untg_vlan = this.has[:untagged_vlan]).nil?
+      this._xml_rm_ac_untagged_vlan( xml )
     end
   end
   
   def self.tr_ac_nountg( this, xml )
-    xml.send :'native-vlan-id', Netconf::JunosConfig::DELETE              
-    xml.vlan( Netconf::JunosConfig::DELETE ) if this.has[:tagged_vlans]
+    xml.send :'native-vlan-id', Netconf::JunosConfig::DELETE
+    this._xml_rm_these_vlans( xml, this.has[:tagged_vlans ] ) if this.has[:tagged_vlans]    
   end
   
   def self.tr_tr_nountg( this, xml )
     xml.send :'native-vlan-id', Netconf::JunosConfig::DELETE              
   end
   
+  ## ----------------------------------------------------------------
+  ## transition where port WILL-HAVE untagged-vlan
+  ## ----------------------------------------------------------------
+  
   def self.ac_ac_untg( this, xml )
-    xml.vlan( Netconf::JunosConfig::REPLACE ) {
+    this._xml_rm_ac_untagged_vlan( xml )
+    xml.vlan {
       xml.members this.should[:untagged_vlan]
     }            
   end
   
   def self.ac_tr_untg( this, xml )      
+    # move untagged vlan to native-vlan-id ...    
     was_untg_vlan = this.has[:untagged_vlan]
-    
-    xml.vlan( Netconf::JunosConfig::REPLACE ) { 
-      xml.members was_untg_vlan, Netconf::JunosConfig::DELETE if was_untg_vlan
-    }
-    xml.send :'native-vlan-id', this.should[:untagged_vlan]              
+    xml.send :'native-vlan-id', this.should[:untagged_vlan]       
+    this._xml_rm_ac_untagged_vlan( xml ) if was_untg_vlan   
   end
   
-  def self.tr_ac_untg( this, xml )
-    xml.send :'native-vlan-id', Netconf::JunosConfig::DELETE              
-    xml.vlan( Netconf::JunosConfig::REPLACE ) {
-      xml.members this.should[:untagged_vlan]
-    }            
+  def self.tr_ac_untg( this, xml )    
+    xml.send :'native-vlan-id', Netconf::JunosConfig::DELETE 
+    this._xml_rm_these_vlans( xml, this.has[:tagged_vlans ] ) if this.has[:tagged_vlans]         
+    xml.vlan { xml.members this.should[:untagged_vlan] }
   end
   
   def self.tr_tr_untg( this, xml )
@@ -293,25 +331,103 @@ class Junos::Ez::L2ports::Provider::VLAN
   
   def build_catalog
     @catalog = {}    
-    return @catalog if list.empty?
+    return @catalog if list!.empty?
+    
+    list.each do |ifs_name|
+      @ndev.rpc.get_configuration{ |xml|
+        xml.interfaces {
+          xml.interface {
+            xml.name ifs_name
+            xml.unit { xml.name '0' }
+          }
+        }
+      }.xpath('interfaces/interface').each do |ifs_xml|
+        @catalog[ifs_name] = {}
+        unit = ifs_xml.xpath('unit')[0]        
+        xml_read_parser( unit, @catalog[ifs_name] )
+      end
+    end    
     
-    @ndev.rpc.get_configuration{ |xml|
-      xml.interfaces {
-        list.each do |port_name|
-          Nokogiri::XML::Builder.with( xml.parent ) do |x1|
-            x1.interface { x1.name port_name
-              x1.unit { x1.name '0' }
-            }
-          end        
-        end
-      }      
-    }.xpath('interfaces/interface').each do |ifs|
-      ifs_name = ifs.xpath('name').text
-      unit = ifs.xpath('unit')[0]
-      @catalog[ifs_name] = {}
-      xml_read_parser( unit, @catalog[ifs_name] )
-    end
     @catalog
   end
   
-end
+end
+
+##### ---------------------------------------------------------------
+#####               !!!!! PRIVATE METHODS !!!!
+##### ---------------------------------------------------------------
+
+class Junos::Ez::L2ports::Provider::VLAN
+  private
+  
+  def _get_eth_port_vlans_h( ifs_name )
+    
+    got = @ndev.rpc.get_ethernet_switching_interface_information(:interface_name => ifs_name)
+    ret_h = {:untagged => nil, :tagged => Set.new }
+    got.xpath('//interface-vlan-member').each do |vlan|
+      vlan_name = vlan.xpath('interface-vlan-name').text.strip      
+      tgdy = vlan.xpath('interface-vlan-member-tagness').text.strip
+      if tgdy == 'untagged'
+        ret_h[:untagged] = vlan_name
+      else
+        ret_h[:tagged] << vlan_name
+      end
+    end
+    ret_h
+  end
+  
+end
+
+
+### ---------------------------------------------------------------
+### [edit vlans] - for interfaces configured here ...
+### ---------------------------------------------------------------
+
+class Junos::Ez::L2ports::Provider::VLAN
+  
+    def _xml_edit_under_vlans( xml )
+    Nokogiri::XML::Builder.with( xml.doc.root ) do |dot|
+      dot.vlans {
+        return dot
+      }
+    end      
+  end
+  
+  def _xml_rm_under_vlans( xml, vlans )
+    at_vlans = _xml_edit_under_vlans( xml )
+    vlans.each do |vlan_name|
+      Nokogiri::XML::Builder.with( at_vlans.parent ) do |this|
+        this.vlan {
+          this.name vlan_name
+          this.interface( Netconf::JunosConfig::DELETE ) { this.name @name }
+        }
+      end
+    end
+  end
+  
+  def _xml_rm_ac_untagged_vlan( xml )
+    if @under_vlans.empty?
+      xml.vlan Netconf::JunosConfig::DELETE    
+    else
+      _xml_rm_under_vlans( xml, [ @has[:untagged_vlan ] ] )
+      @under_vlans = []    
+    end
+  end
+  
+  def _xml_rm_these_vlans( xml, vlans )
+    if @under_vlans.empty?
+      xml.vlan( Netconf::JunosConfig::DELETE ) 
+    else
+      # could be a mix between [edit vlans] and [edit interfaces] ...
+      v_has = vlans.to_set
+      del_under_vlans = v_has & @under_vlans
+      _xml_rm_under_vlans( xml, del_under_vlans )
+      if v_has ^ @under_vlans
+        xml.vlan( Netconf::JunosConfig::DELETE ) 
+      end
+      @under_vlans = []        
+    end
+  end
+  
+end
+

data/lib/junos-ez/provider.rb

@@ -5,11 +5,13 @@
 ##### scope of impact.  Thank you.
 ##### ---------------------------------------------------------------
 
+require 'set'
+
 module Junos; end
   
 module Junos::Ez
   
-  VERSION = "0.0.12"
+  VERSION = "0.0.15"
   
   ### ---------------------------------------------------------------
   ### rpc_errors - decodes the XML into an array of error/Hash
@@ -286,6 +288,7 @@ class Junos::Ez::Provider::Parent
     xml = xml_at_top
     par = xml.instance_variable_get(:@parent)    
     par['delete'] = 'delete'
+    xml_on_delete( xml )
     rsp = write_xml_config!( xml.doc.root )
     @has[:_exist] = false
     true # rsp ... don't return XML, but let's hear from the community...

data/lib/junos-ez/utils/config.rb

@@ -10,6 +10,7 @@ configuration files/templates and software images
    lock! - take exclusive lock on config
    unlock! - release exclusive lock on config
    rollback! - perform a config rollback
+   get_config - returns requested config in "text" format-style
    
 ---------------------------------------------------------------------
 =end
@@ -162,7 +163,7 @@ class Junos::Ez::Config::Provider < Junos::Ez::Provider::Parent
   ### current candidate configuration loaded and the rollback_id
   ###
   ### --- returns ---
-  ###    false if no diff
+  ###    nil if no diff
   ###    String of diff output otherwise
   ### ---------------------------------------------------------------
   
@@ -170,7 +171,7 @@ class Junos::Ez::Config::Provider < Junos::Ez::Provider::Parent
     raise ArgumentError, "invalid rollback #{rollback_id}" unless ( rollback_id >= 0 and rollback_id <= 50 )    
     got = ndev.rpc.get_configuration( :compare=>'rollback', :rollback=> rollback_id.to_s )
     diff = got.xpath('configuration-output').text
-    return false if diff == "\n"
+    return nil if diff == "\n"
     diff
   end
   
@@ -200,6 +201,36 @@ class Junos::Ez::Config::Provider < Junos::Ez::Provider::Parent
     true
   end
   
+  ### ---------------------------------------------------------------
+  ### get_config - returns String of requested (or entire) config
+  ### in "text" (curly-brace) format.  The 'rqst' argument 
+  ### identifies the scope of the config, for example:
+  ###
+  ### .get_config( "interfaces ge-0/0/0" )
+  ###
+  ### If there is no configuration available, 'nil' is returned
+  ###
+  ### If there is an error in the request, that will be returned 
+  ###   as a String with "ERROR!" prepended
+  ### ---------------------------------------------------------------
+  
+  def get_config( rqst = nil )
+    scope = "show configuration"
+    scope.concat( " " + rqst ) if rqst
+    begin
+      @ndev.rpc.command( scope, :format => 'text' ).xpath('configuration-output').text
+    rescue NoMethodError
+      # indicates no configuration found
+      nil
+    rescue => e
+      # indicates error in request 
+      err = e.rsp.xpath('rpc-error')[0]
+      err_info = err.xpath('error-info/bad-element').text
+      err_msg = err.xpath('error-message').text
+      "ERROR! " + err_msg + ": " + err_info
+    end
+  end
+  
 end # class Provider