shopify-junos-ez-stdlib 1.0.0

data/lib/junos-ez/system/users.rb

@@ -0,0 +1,217 @@
+=begin
+=end
+
+require 'junos-ez/system/userauths'
+
+module Junos::Ez::Users
+
+  PROPERTIES = [ 
+    :uid,                     # User-ID, Number
+    :class,                   # User Class, String
+    :fullname,                # Full Name, String
+    :password,                # Encrypted password  
+    :ssh_keys,                # READ-ONLY, Hash of SSH public keys
+  ]  
+
+  def self.Provider( ndev, varsym )            
+    newbie = Junos::Ez::Users::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; end
+    
+end
+
+
+##### ---------------------------------------------------------------
+##### Provider Resource Methods
+##### ---------------------------------------------------------------
+
+class Junos::Ez::Users::Provider 
+  
+  ### ---------------------------------------------------------------
+  ### XML top placement
+  ### ---------------------------------------------------------------
+  
+  def xml_at_top
+    Nokogiri::XML::Builder.new{|x| x.configuration{ 
+      x.system { x.login { x.user { 
+        x.name @name
+        return x
+    }}}}}
+  end
+
+  ### ---------------------------------------------------------------
+  ### XML readers
+  ### ---------------------------------------------------------------
+
+  def xml_get_has_xml( xml )
+    xml.xpath('//user')[0]    
+  end
+        
+  def xml_read_parser( as_xml, as_hash )
+    set_has_status( as_xml, as_hash )    
+    
+    as_hash[:uid] = as_xml.xpath('uid').text
+    as_hash[:class] = as_xml.xpath('class').text
+    
+    xml_when_item(as_xml.xpath('full-name')) {|i|
+      as_hash[:fullname] = i.text
+    }
+    
+    xml_when_item(as_xml.xpath('authentication/encrypted-password')) {|i|
+      as_hash[:password] = i.text
+    }
+  
+    # READ-ONLY capture the keys
+    unless (keys = as_xml.xpath('authentication/ssh-rsa')).empty?
+      as_hash[:ssh_keys] ||= {}
+      as_hash[:ssh_keys]['ssh-rsa'] = keys.collect{|key| key.text.strip}
+    end
+    unless (keys = as_xml.xpath('authentication/ssh-dsa')).empty?
+      as_hash[:ssh_keys] ||= {}      
+      as_hash[:ssh_keys]['ssh-dsa'] = keys.collect{|key| key.text.strip}
+    end
+  end  
+
+  ### ---------------------------------------------------------------    
+  ### XML writers
+  ### ---------------------------------------------------------------  
+  
+  def xml_change_password( xml )           
+    xml.authentication {
+      xml_set_or_delete( xml, 'encrypted-password', @should[:password] )
+    }
+  end
+  
+  def xml_change_fullname( xml )     
+    xml_set_or_delete( xml, 'full-name', @should[:fullname] )
+  end   
+  
+  # changing the 'gid' is changing the Junos 'class' element
+  # so, what is tough here is that the Nokogiri Builder mech
+  # won't allow us to use the string 'class' since it conflicts
+  # with the Ruby language.  So we need to add the 'class' element
+  # the hard way, yo! ...
+  
+  def xml_change_class( xml )  
+    par = xml.instance_variable_get(:@parent)    
+    doc = xml.instance_variable_get(:@doc)        
+    user_class = Nokogiri::XML::Node.new('class', doc )
+    user_class.content = @should[:class]
+    par.add_child( user_class )    
+  end    
+  
+  def xml_change_uid( xml )
+    xml_set_or_delete( xml, 'uid', @should[:uid] )
+  end
+  
+end
+
+##### ---------------------------------------------------------------
+##### Provider Collection Methods
+##### ---------------------------------------------------------------
+
+class Junos::Ez::Users::Provider
+  
+  def build_list
+    @ndev.rpc.get_configuration{ |x| x.system {
+      x.login {
+        x.user({:recurse => 'false'})
+      }
+    }}
+    .xpath('//user/name').collect{ |i| i.text }
+  end
+  
+  def build_catalog
+    @catalog = {}
+    @ndev.rpc.get_configuration{ |x| x.system {
+      x.login
+    }}
+    .xpath('//user').each do |user|
+      name = user.xpath('name').text
+      @catalog[name] = {}
+      xml_read_parser( user, @catalog[name] )
+    end
+    @catalog
+  end
+  
+end
+
+##### ---------------------------------------------------------------
+##### Resource Methods
+##### ---------------------------------------------------------------
+
+class Junos::Ez::Users::Provider
+  
+  ## ----------------------------------------------------------------
+  ## change the password by providing it in plain-text
+  ## ----------------------------------------------------------------
+  
+  def password=(plain_text)
+    xml = xml_at_top
+    xml.authentication {
+      xml.send(:'plain-text-password-value', plain_text)
+    }
+    @ndev.rpc.load_configuration( xml )
+    return true
+  end
+  
+  ## ----------------------------------------------------------------
+  ## get a Hash that is used as the 'name' for obtaining a resource
+  ## for Junos::Ez::UserAuths::Provider
+  ## ----------------------------------------------------------------
+
+  def ssh_key( keytype, index = 0 )
+    return nil unless @has[:ssh_keys]
+    return nil unless @has[:ssh_keys][keytype]    
+    ret_h = {:user => @name, :keytype => keytype}
+    ret_h[:publickey] = @has[:ssh_keys][keytype][index]
+    ret_h
+  end
+  
+  ##
+  ## @@ need to move this code into the main provider
+  ## @@ as a utility  ...
+  ##
+  
+  def get_userauth_provd
+    @ndev.providers.each do |p|
+      obj = @ndev.send(p)
+      return obj if obj.class == Junos::Ez::UserAuths::Provider
+    end
+  end
+  
+  ## ----------------------------------------------------------------
+  ## load an SSH public key  & return the resulting key object.
+  ## You can provide the publickey either as :publickey or
+  ## contents will be read from :filename
+  ## ----------------------------------------------------------------
+
+  def load_ssh_key!( opts = {} )
+    publickey = opts[:publickey] || File.read( opts[:filename] ).strip
+    raise ArgumentError, "no public-key specified" unless publickey
+    
+    # nab the provider for handling ssh-keys, since we'll use that
+    # for key resource management
+    
+    @auth_provd ||= get_userauth_provd    
+    raise StandardError, "No Junos::Ez::UserAuths::Provider" unless @auth_provd
+    
+    # extract the key-type from the public key.
+    keytype = publickey[0..6]
+    keytype = 'ssh-dsa' if keytype == 'ssh-dss'
+    raise ArgumentError, "Unknown ssh key-type #{keytype}" unless Junos::Ez::UserAuths::VALID_KEY_TYPES.include? keytype
+    
+    # ok, we've got everything we need to add the key, so here we go.
+    key_name = {:user => @name, :keytype => keytype, :publickey => publickey }
+    key = @auth_provd[ key_name ]
+    key.write!
+    
+    # return the key in case the caller wants it
+    key
+  end
+  
+end
+

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

@@ -0,0 +1,236 @@
+=begin
+---------------------------------------------------------------------
+Config::Utils is a collection of methods used for loading 
+configuration files/templates and software images
+
+   commit! - commit configuration
+   commit? - see if a candidate config is OK (commit-check)
+   diff? - shows the diff of the candidate config w/current | rolback
+   load! - load configuration onto device
+   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
+
+module Junos::Ez::Config  
+  def self.Utils( ndev, varsym )            
+    newbie = Junos::Ez::Config::Provider.new( ndev )      
+    Junos::Ez::Provider.attach_instance_variable( ndev, varsym, newbie )    
+  end          
+end
+
+### -----------------------------------------------------------------
+###                        PUBLIC METHODS
+### -----------------------------------------------------------------
+### -----------------------------------------------------------------
+
+class Junos::Ez::Config::Provider < Junos::Ez::Provider::Parent
+  
+  ### ---------------------------------------------------------------
+  ### load! - used to load configuration files / templates.  This
+  ###    does not perform a 'commit', just the equivalent of the
+  ###    load-configuration RPC
+  ###
+  ### --- options ---
+  ###
+  ### :filename => path - indcates the filename of content
+  ###    note: filename extension will also define format
+  ###    .{conf,text,txt} <==> :text
+  ###    .xml  <==> :xml
+  ###    .set  <==> :set
+  ###
+  ### :content => String - string content of data (vs. :filename)
+  ###  
+  ### :format =>  [:text, :set, :xml], default :text (curly-brace)
+  ###    this will override any auto-format from the :filename
+  ###
+  ### :binding  - indicates file/content is an ERB
+  ###    => <object> - will grab the binding from this object
+  ###                  using a bit of meta-programming magic
+  ###    => <binding> - will use this binding
+  ###
+  ### :replace! => true - enables the 'replace' option
+  ### :overwrite! => true - enables the 'overwrite' optoin
+  ###
+  ### --- returns ---
+  ###   true if the configuration is loaded OK
+  ###   raise Netconf::EditError otherwise
+  ### ---------------------------------------------------------------
+  
+  def load!( opts = {} )
+    raise ArgumentError unless opts[:content] || opts[:filename]
+    
+    content = opts[:content] || File.read( opts[:filename] )    
+    
+    attrs = {}
+    attrs[:action] = 'replace' if opts[:replace!]      
+    attrs[:action] = 'override' if opts[:override!]       
+    
+    if opts[:format] 
+      attrs[:format] = opts[:format].to_s
+    elsif opts[:filename]
+      case f_ext = File.extname( opts[:filename] )
+      when '.conf','.text','.txt'; attrs[:format] = 'text'
+      when '.set'; attrs[:format] = 'set'
+      when '.xml'; # default is XML
+      else
+        raise ArgumentError, "unknown format from extension: #{f_ext}"
+      end
+    else
+      raise ArgumentError "unspecified format"
+    end   
+        
+    if opts[:binding]
+      erb = ERB.new( content, nil, '>' )
+      case opts[:binding]
+      when Binding
+        # binding was provided to use
+        content = erb.result( opts[:binding] )
+      when Object
+        obj = opts[:binding]
+        def obj.junos_ez_binding; binding end
+        content = erb.result( obj.junos_ez_binding )
+        class << obj; remove_method :junos_ez_binding end
+      end
+    end
+    
+    @ndev.rpc.load_configuration( content, attrs ) 
+    true # everthing OK!    
+  end
+  
+  ### ---------------------------------------------------------------
+  ### commit! - commits the configuration to the device
+  ### 
+  ### --- options ---
+  ###
+  ### :confirm => true | timeout 
+  ### :comment => commit log comment
+  ###
+  ### --- returns ---
+  ###    true if commit completed
+  ###    raises Netconf::CommitError otherwise
+  ### ---------------------------------------------------------------
+  
+  def commit!( opts = {} )
+    
+    args = {}
+    args[:log] = opts[:comment] if opts[:comment]
+    if opts[:confirm] 
+      args[:confirmed] = true
+      if opts[:confirm] != true
+        timeout = Integer( opts[:confirm] ) rescue false
+        raise ArgumentError "invalid timeout #{opts[:confirm]}" unless timeout
+        args[:confirm_timeout] = timeout
+      end
+    end
+    
+    @ndev.rpc.commit_configuration( args )
+    true          
+  end
+
+  ### ---------------------------------------------------------------
+  ### commit? - perform commit configuration check
+  ###
+  ### --- returns ---
+  ###    true if candidate config is OK to commit
+  ###    Array of rpc-error data otherwise
+  ### ---------------------------------------------------------------
+
+  def commit?        
+    begin
+      @ndev.rpc.commit_configuration( :check => true ) 
+    rescue => e
+      return Junos::Ez::rpc_errors( e.rsp )
+    end
+    true     # commit check OK!
+  end
+  
+  ### ---------------------------------------------------------------
+  ### rollback! - used to rollback the configuration
+  ### ---------------------------------------------------------------
+  
+  def rollback!( rollback_id = 0 )    
+    raise ArgumentError, "invalid rollback #{rollback_id}" unless ( rollback_id >= 0 and rollback_id <= 50 )    
+    @ndev.rpc.load_configuration( :compare=>'rollback', :rollback=> rollback_id.to_s )
+    true   # rollback OK!
+  end
+
+  ### ---------------------------------------------------------------
+  ### diff? - displays diff (patch format) between
+  ### current candidate configuration loaded and the rollback_id
+  ###
+  ### --- returns ---
+  ###    nil if no diff
+  ###    String of diff output otherwise
+  ### ---------------------------------------------------------------
+  
+  def diff?( rollback_id = 0 )
+    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 nil if diff == "\n"
+    diff
+  end
+  
+  ### ---------------------------------------------------------------
+  ### lock! - takes an exclusive lock on the candidate config
+  ###
+  ### --- returns ---
+  ###    true if lock acquired
+  ###    raise Netconf::LockError otherwise
+  ### ---------------------------------------------------------------
+  
+  def lock!
+    @ndev.rpc.lock_configuration
+    true
+  end
+
+  ### ---------------------------------------------------------------
+  ### unlock! - releases exclusive lock on candidate config
+  ###
+  ### --- returns ---
+  ###    true if lock release
+  ###    raise Netconf::RpcError otherwise
+  ### ---------------------------------------------------------------
+  
+  def unlock!
+    @ndev.rpc.unlock_configuration
+    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    
+
+