shopify-junos-ez-stdlib 1.0.0

data/lib/junos-ez/group.rb

@@ -0,0 +1,206 @@
+require "junos-ez/provider"
+
+module Junos::Ez::Group
+
+  PROPERTIES = [ 
+    :format,     # [:set, :text, :xml]  
+    :path,       # Configuration file path
+]  
+  
+  def self.Provider( ndev, varsym )            
+    newbie = Junos::Ez::Group::Provider::new( ndev )            
+    newbie.properties = Junos::Ez::Provider::PROPERTIES + PROPERTIES
+    Junos::Ez::Provider.attach_instance_variable( ndev, varsym, newbie )
+  end
+  
+  class Provider < Junos::Ez::Provider::Parent
+    # common parenting goes here ... if we were to
+    # subclass the objects ... not doing that now
+  end
+  
+end
+
+class Junos::Ez::Group::Provider 
+
+  ### ---------------------------------------------------------------
+  ### XML top placement
+  ### ---------------------------------------------------------------
+  
+  def xml_at_top
+    xml = Nokogiri::XML::Builder.new {|xml| xml.configuration {
+      xml.groups {
+        xml.name @name
+        return xml
+      }
+    }}
+  end
+  
+  ### ---------------------------------------------------------------
+  ### XML property readers
+  ### ---------------------------------------------------------------  
+
+  def xml_get_has_xml( xml ) 
+    xml.xpath('//groups')[0]
+  end
+  
+  def xml_read_parser( as_xml, as_hash )    
+    set_has_status( as_xml, as_hash )  
+    
+    grp = as_xml.xpath('name').text
+    as_hash[:name] = grp unless grp.empty?
+
+  end
+  
+
+  ### ---------------------------------------------------------------
+  ### XML property writers
+  ### ---------------------------------------------------------------    
+  
+  def xml_change_path( xml )
+  end
+  
+  def xml_change_format( xml )
+  end
+  
+  ### ---------------------------------------------------------------
+  ### XML on-create
+  ### ---------------------------------------------------------------  
+  
+  def xml_on_create( xml )
+  end
+  
+  ### ---------------------------------------------------------------
+  ### XML on-delete
+  ### ---------------------------------------------------------------      
+  def xml_on_delete( xml )
+  end
+
+  def write_xml_config!( xml, opts = {} )
+    if (@should[:_exist] == true)
+      _load ( xml )
+      @should[:format] = 'xml' unless @should[:format]
+      begin
+        attr = {}
+        attr[:action] = 'replace'
+        attr[:format] = @should[:format].to_s
+        result = @ndev.rpc.load_configuration( @config.to_s, attr  )
+      rescue Netconf::RpcError => e      
+        errs = e.rsp.xpath('//rpc-error[error-severity = "error"]')
+        raise e unless errs.empty?
+        e.rsp
+      else
+        result
+      end
+    else
+      super(xml) 
+    end
+    _apply_group
+  end
+  
+ def write!
+    return nil if @should.empty?
+    
+    @should[:_exist] ||= true
+    @should[:_active] ||= :true
+    # load the conifguration from file and apply under group
+    # hirerachy
+    rsp = write_xml_config!( xml_at_top.doc.root )    
+    
+    # copy the 'should' values into the 'has' values now that 
+    # they've been written back to Junos
+        
+    @has.merge! @should 
+    @should.clear
+    
+    return true
+  end
+
+end
+
+  
+##### ---------------------------------------------------------------
+##### Provider collection methods
+##### ---------------------------------------------------------------
+
+class Junos::Ez::Group::Provider
+
+  def build_list
+    grp_cfgs = @ndev.rpc.get_configuration{|xml| 
+      xml.send(:'groups')
+    }.xpath('groups/name').collect do |item|
+      item.text
+    end 
+    return grp_cfgs
+  end
+  
+  def build_catalog
+    return @catalog if list!.empty?
+    list.each do |grp_name|
+      @ndev.rpc.get_configuration{ |xml|
+        xml.groups {
+            xml.name grp_name
+          }
+      }.xpath('groups').each do |as_xml|
+        @catalog[grp_name] = {}
+        xml_read_parser( as_xml, @catalog[grp_name] )
+      end
+    end    
+    @catalog
+    end
+end
+
+##### ---------------------------------------------------------------
+##### _PRIVATE methods
+##### ---------------------------------------------------------------
+
+class Junos::Ez::Group::Provider 
+
+  def _load ( xml )
+    return @config = nil if ( @should[:_exist] == false )
+    admin = '' 
+    if @should[:format].to_s == 'set'
+      @config =  "\ndelete groups #{@name}\n" +
+                   "edit groups #{@name}\n" + 
+                    File.read( @should[:path] ) 
+      admin = @should[:_active] == :false ? 'deactivate' : 'activate'
+      @config += "\nquit\n"
+      @config += "\n#{admin} groups #{@name}"
+
+    elsif @should[:format].to_s == 'text'
+      admin = @should[:_active] == :false ? 'inactive' : 'active'
+      admin += ": " unless admin.empty? 
+      @config = "groups {\n#{admin} replace: #{@name} {\n" + 
+                File.read( @should[:path] ) + "\n}\n}"
+
+    elsif @should[:format].to_s == 'xml'
+      xml.at_xpath('groups') << File.read( @should[:path])
+      @config = xml
+    end
+    return @config
+  end
+  
+  def _apply_group
+    cfg = Netconf::JunosConfig.new(:TOP)
+    xml = cfg.doc
+    Nokogiri::XML::Builder.with( xml.at_xpath( 'configuration' )) do |dot|
+      if @config and @should[:_active] == :true  
+        dot.send :'apply-groups', @name
+      else 
+        dot.send :'apply-groups', @name, Netconf::JunosConfig::DELETE
+      end
+    end
+    begin
+      attr = {}
+      attr[:action] = 'replace'
+      attr[:format] = 'xml'
+      result = @ndev.rpc.load_configuration( xml, attr  )
+    rescue Netconf::RpcError => e      
+      errs = e.rsp.xpath('//rpc-error[error-severity = "error"]')
+      raise e unless errs.empty?
+      e.rsp
+    else
+      result
+    end
+  end
+end
+

data/lib/junos-ez/ip_ports.rb

@@ -0,0 +1,30 @@
+
+require "junos-ez/provider"
+
+module Junos::Ez::IPports
+
+  PROPERTIES = [ 
+    :admin,             # [:up, :down]
+    :description,       # general description text
+    :tag_id,            # VLAN tag-id for vlan-tag enabled ports
+    :mtu,               # MTU value as number
+    :address,           # ip/prefix as text, e.g. "192.168.10.22/24"
+    :acl_in,            # input ACL name
+    :acl_out,           # output ACL name
+  ]  
+
+  def self.Provider( ndev, varsym )            
+    newbie = Junos::Ez::IPports::Provider::CLASSIC.new( ndev )      
+    newbie.properties = Junos::Ez::Provider::PROPERTIES + PROPERTIES
+    Junos::Ez::Provider.attach_instance_variable( ndev, varsym, newbie )    
+  end
+  
+  class Provider < Junos::Ez::Provider::Parent
+    # common parenting goes here ...
+  end
+  
+end
+
+require 'junos-ez/ip_ports/classic'
+
+

data/lib/junos-ez/ip_ports/classic.rb

@@ -0,0 +1,188 @@
+class Junos::Ez::IPports::Provider::CLASSIC < Junos::Ez::IPports::Provider
+  
+  ### ---------------------------------------------------------------
+  ### XML top placement
+  ### ---------------------------------------------------------------
+  
+  def xml_at_top    
+    
+    # if just the IFD is given as the name, default to unit "0"
+    @ifd, @ifd_unit = @name.split '.'
+    @ifd_unit ||= "0"
+    
+    Nokogiri::XML::Builder.new{ |x| x.configuration{ 
+      x.interfaces { x.interface { x.name @ifd
+        x.unit {
+          x.name @ifd_unit
+          return x
+        }
+      }}
+    }}
+  end
+  
+  def xml_element_rename( new_name )
+    
+    # if just the IFD is given as the name, default to unit "0"
+    n_ifd, n_ifl = new_name.split '.'
+    n_ifl ||= "0"
+    
+    # do not allow rename to different IFD.
+    return false unless @ifd == n_ifd
+    
+    # return the new element name
+    return n_ifl
+  end
+  
+  ### ---------------------------------------------------------------
+  ### XML readers
+  ### ---------------------------------------------------------------
+
+  def xml_get_has_xml( xml )
+    xml.xpath('//unit')[0]
+  end
+    
+  def xml_read_parser( as_xml, as_hash )
+    set_has_status( as_xml, as_hash )    
+
+    as_hash[:admin] = as_xml.xpath('disable').empty? ? :up : :down    
+    ifa_inet = as_xml.xpath('family/inet')
+    
+    xml_when_item(as_xml.xpath('vlan-id')){ |i| as_hash[:tag_id] = i.text.to_i }
+    xml_when_item(as_xml.xpath('description')){ |i| as_hash[:description] = i.text }
+    xml_when_item(ifa_inet.xpath('mtu')){ |i| as_hash[:mtu] = i.text.to_i }   
+    
+    # The address could be a list.
+    address = []
+    ifa_inet.xpath('address').each do |addr|
+      address << addr.xpath('name').text
+    end
+    as_hash[:address] = address || nil
+    
+    # check for firewall-filters (aka ACLs)
+    if (fw_acl = ifa_inet.xpath('filter')[0])
+      xml_when_item( fw_acl.xpath('input/filter-name')){ |i| as_hash[:acl_in] = i.text.strip }
+      xml_when_item( fw_acl.xpath('output/filter-name')){ |i| as_hash[:acl_out] = i.text.strip }
+    end
+    
+    return true
+  end  
+  
+  ### ---------------------------------------------------------------
+  ### XML writers
+  ### ---------------------------------------------------------------
+  
+  def xml_change_address( xml )
+    xml.family { xml.inet {
+      # delete the old address and replace it with the new one ...
+      if @has[:address]
+        xml.address( Netconf::JunosConfig::DELETE ) { xml.name @has[:address] }
+      end
+      xml.address { xml.name @should[:address] }
+    }}
+  end
+  
+  def xml_change_tag_id( xml )
+    xml_set_or_delete( xml, 'vlan-id', @should[:tag_id] )
+  end
+
+  def xml_change_mtu( xml )
+    xml.family { xml.inet {
+      xml_set_or_delete( xml, 'mtu', @should[:mtu] )
+    }}
+  end   
+  
+  def xml_change_acl_in( xml )
+    xml.family { xml.inet { xml.filter { xml.input {
+      xml_set_or_delete( xml, 'filter-name', @should[:acl_in] )
+    }}}}
+  end
+  
+  def xml_change_acl_out( xml )
+    xml.family { xml.inet { xml.filter { xml.output {
+      xml_set_or_delete( xml, 'filter-name', @should[:acl_out] )      
+    }}}}    
+  end
+
+end
+
+##### ---------------------------------------------------------------
+##### Resource Methods
+##### ---------------------------------------------------------------
+
+class Junos::Ez::IPports::Provider::CLASSIC
+  def status
+    got = @ndev.rpc.get_interface_information( :interface_name => @ifd+'.'+@ifd_unit )
+    ifs = got.xpath('logical-interface')[0]  
+    ret_h = {}
+    ret_h[:l1_oper_status] = (ifs.xpath('if-config-flags/iff-device-down')[0]) ? :down : :up
+    ret_h[:oper_status] = (ifs.xpath('address-family//ifaf-down')[0]) ? :down : :up    
+    ret_h[:snmp_index] = ifs.xpath('snmp-index').text.to_i
+    ret_h[:packets_rx] = ifs.xpath('traffic-statistics/input-packets').text.to_i
+    ret_h[:packets_tx] = ifs.xpath('traffic-statistics/output-packets').text.to_i
+    ret_h
+  end
+end
+
+##### ---------------------------------------------------------------
+##### Provider collection methods
+##### ---------------------------------------------------------------
+
+class Junos::Ez::IPports::Provider::CLASSIC
+  
+  def build_list            
+    from_junos_get_ifa_xml.collect do |ifa|
+      ifa.xpath('name').text.strip
+    end                
+  end
+  
+  def build_catalog
+    @catalog = {}
+
+    ## do the equivalent of "show interfaces ..." to retrieve the list
+    ## of known interfaces that have an IFA == 'inet'.  Note that this
+    ## list will *not* include anything that has been deactivated.
+    
+    ifa_list = from_junos_get_ifa_xml
+    
+    ## from this list of IFA, retrieve the configurations
+    
+    got_xml_cfg = @ndev.rpc.get_configuration do |cfg|
+      cfg.interfaces {
+        ifa_list.each do |ifa|
+          ifa_name = ifa.xpath('name').text.strip
+          ifa_ifd, ifa_ifl = ifa_name.split '.'
+          cfg.interface { 
+            cfg.name ifa_ifd 
+            cfg.unit { cfg.name ifa_ifl }
+          }
+        end
+      }
+    end    
+    
+    ## now create the object property hashes for each of the instances
+    
+    got_xml_cfg.xpath('interfaces/interface/unit').each do |ifl|      
+      ifd = ifl.xpath('preceding-sibling::name').text.strip
+      unit = ifl.xpath('name').text.strip
+      obj_name = ifd + '.' + unit
+      
+      @catalog[obj_name] = {}
+      xml_read_parser( ifl, @catalog[obj_name] )
+    end
+    
+    return @catalog
+  end
+  
+  private
+  
+  def from_junos_get_ifa_xml
+    
+    xml_data = @ndev.rpc.get_interface_information( 
+      :terse => true,
+      )
+    
+    ifa_list = xml_data.xpath('interface-information/logical-interface[normalize-space(address-family/address-family-name) = "inet"]')    
+    
+  end
+  
+end

data/lib/junos-ez/l1_ports.rb

@@ -0,0 +1,121 @@
+require "junos-ez/provider"
+
+module Junos::Ez::L1ports
+
+  PROPERTIES = [ 
+    :admin,               # [ :up, :down ]
+    :description,         # string
+    :mtu,                 # number
+    :speed,               # [ :auto, '10m', '100m', '1g', '10g' ]
+    :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 )
+    when :SWITCH
+      Junos::Ez::L1ports::Provider::SWITCH.new( ndev )            
+    when :CLASSIC
+      Junos::Ez::L1ports::Provider::CLASSIC.new( ndev )      
+    end      
+    
+    newbie.properties = Junos::Ez::Provider::PROPERTIES + PROPERTIES
+    Junos::Ez::Provider.attach_instance_variable( ndev, varsym, newbie )
+  end
+  
+end
+
+class Junos::Ez::L1ports::Provider < Junos::Ez::Provider::Parent
+  
+  ### ---------------------------------------------------------------
+  ### XML readers
+  ### ---------------------------------------------------------------
+
+  def xml_get_has_xml( xml )
+    xml.xpath('//interface')[0]
+  end
+    
+  def xml_change_mtu( xml )
+    xml_set_or_delete( xml, 'mtu', @should[:mtu] )
+  end
+  
+  ### ---------------------------------------------------------------
+  ###  Collection methods
+  ### ---------------------------------------------------------------  
+  
+  def build_list
+    @ndev.rpc.get_interface_information({
+        :media => true,
+        :terse => true,
+        :interface_name => Junos::Ez::L1ports::IFS_NAME_FILTER
+    }).xpath('physical-interface/name').collect do |ifs|
+      ifs.text.strip
+    end
+  end
+  
+  def build_catalog
+    @catalog = {}
+    
+    # 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_name
+            xml_read_filter( xml )
+          }
+        }
+      }.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'
+require 'junos-ez/l1_ports/classic'
+