cisco_node_utils 1.1.0 → 1.2.0

data/lib/cisco_node_utils/name_server.rb

@@ -3,7 +3,7 @@
 #
 # September 2015, Hunter Haugen
 #
-# Copyright (c) 2015 Cisco and/or its affiliates.
+# Copyright (c) 2015-2016 Cisco and/or its affiliates.
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.

data/lib/cisco_node_utils/node.rb

@@ -4,7 +4,7 @@
 #
 # December 2014, Glenn F. Matthews
 #
-# Copyright (c) 2014-2015 Cisco and/or its affiliates.
+# Copyright (c) 2014-2016 Cisco and/or its affiliates.
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.
@@ -50,10 +50,6 @@ module Cisco
   class Node
     include Singleton
 
-    # BEGIN NODE API
-    # This is most of what a client/provider should need to code against.
-    # Actual implementations of these methods are later in this file.
-
     # Convenience wrapper for show(command, :structured).
     # Uses CommandReference to look up the given show command and key
     # of interest, executes that command, and returns the value corresponding
@@ -69,46 +65,64 @@ module Cisco
     # @return [String, Hash, Array]
     # @example config_get("show_version", "system_image")
     # @example config_get("ospf", "router_id",
-    #                      {:name => "green", :vrf => "one"})
+    #                     {name: "green", vrf: "one"})
     def config_get(feature, name, *args)
       fail 'lazy_connect specified but did not request connect' unless @cmd_ref
       ref = @cmd_ref.lookup(feature, name)
 
+      return ref.default_value if ref.default_only?
+
       begin
-        token = build_config_get_token(feature, ref, args)
-      rescue IndexError, TypeError
-        # IndexError if value is not set, TypeError if set to nil explicitly
+        token = ref.config_get_token(*args)
+      rescue IndexError
+        # IndexError: no entry for config_get_token
         token = nil
       end
-      if token.kind_of?(String)
-        if token[0] == '/' && token[-1] == '/'
-          fail RuntimeError unless args.length == token.scan(/%/).length
-          # convert string to regexp and replace %s with args
-          token = Regexp.new(sprintf(token, *args)[1..-2])
-          text = build_config_get(feature, ref, :ascii)
-          return Cisco.find_ascii(text, token)
-        else
-          hash = build_config_get(feature, ref, :structured)
-          return hash[token]
-        end
-      elsif token.kind_of?(Array)
-        # Array of /regexps/ -> ascii, array of strings/ints -> structured
-        if token[0].kind_of?(String) &&
-           token[0][0] == '/' &&
-           (token[0][-1] == '/' || token[0][-2..-1] == '/i')
-
-          token = token_str_to_regexp(token, args)
-          text = build_config_get(feature, ref, :ascii)
-          return Cisco.find_ascii(text, token[-1], *token[0..-2])
+      if token.nil?
+        # Just get the whole output
+        return massage(show(ref.config_get, :structured), ref)
+      elsif token[0].kind_of?(Regexp)
+        return massage(Cisco.find_ascii(show(ref.config_get, :ascii),
+                                        token[-1],
+                                        *token[0..-2]), ref)
+      else
+        return massage(
+          config_get_handle_structured(token,
+                                       show(ref.config_get, :structured)),
+          ref)
+      end
+    end
 
+    # Attempt to massage the given value into the format specified by the
+    # given CmdRef object.
+    def massage(value, ref)
+      CiscoLogger.debug "Massaging '#{value}' (#{value.inspect})"
+      if value.is_a?(Array) && !ref.multiple
+        fail "Expected zero/one value but got '#{value}'" if value.length > 1
+        value = value[0]
+      end
+      if (value.nil? || value.empty?) && ref.default_value? && ref.auto_default
+        CiscoLogger.debug "Default: #{ref.default_value}"
+        return ref.default_value
+      end
+      return value unless ref.kind
+      case ref.kind
+      when :boolean
+        if value.nil? || value.empty?
+          value = false
+        elsif /^no / =~ value
+          value = false
         else
-          result = build_config_get(feature, ref, :structured)
-          return config_get_handle_structured(token, result)
+          value = true
         end
-      elsif token.nil?
-        return show(ref.config_get, :structured)
+      when :int
+        value = value.to_i unless value.nil?
+      when :string
+        value = '' if value.nil?
+        value = value.to_s.strip
       end
-      fail TypeError("Unclear to handle config_get_token #{token}")
+      CiscoLogger.debug "Massaged to '#{value}'"
+      value
     end
 
     # Uses CommandReference to lookup the default value for a given
@@ -144,31 +158,7 @@ module Cisco
     def config_set(feature, name, *args)
       fail 'lazy_connect specified but did not request connect' unless @cmd_ref
       ref = @cmd_ref.lookup(feature, name)
-      config_set = build_config_set(feature, ref, args)
-      if config_set.is_a?(String)
-        param_count = config_set.scan(/%/).length
-      elsif config_set.is_a?(Array)
-        param_count = config_set.join(' ').scan(/%/).length
-      else
-        fail TypeError, '%{config_set.class} not supported for config_set'
-      end
-      unless args[0].is_a? Hash
-        if param_count != args.length
-          fail ArgumentError, 'Wrong number of params - expected: ' \
-          "#{param_count} actual: #{args.length}"
-        end
-      end
-      if config_set.is_a?(String)
-        config(sprintf(config_set, *args))
-      elsif config_set.is_a?(Array)
-        new_config_set = []
-        config_set.each do |line|
-          param_count = line.scan(/%/).length
-          new_config_set << sprintf(line, *args.first(param_count))
-          args = args[param_count..-1]
-        end
-        config(new_config_set)
-      end
+      config(ref.config_set(*args))
     end
 
     # Clear the cache of CLI output results.
@@ -209,7 +199,10 @@ module Cisco
     # "hidden" API - used for UT but shouldn't be used elsewhere
     def connect(*args)
       @client = CiscoNxapi::NxapiClient.new(*args)
-      @cmd_ref = CommandReference::CommandReference.new(product_id)
+      # Hard-code platform and cli for now
+      @cmd_ref = CommandReference.new(product:  product_id,
+                                      platform: :nexus,
+                                      cli:      true)
       cache_flush
     end
 
@@ -234,159 +227,6 @@ module Cisco
       @client.cache_auto = enable
     end
 
-    # Helper method for converting token strings to regexps. This helper
-    # facilitates non-standard regexp options like ignore-case.
-    # Example inputs:
-    #  token = ["/%s/i", "/%s foo %s/", "/zzz/i"]
-    #  args = ["LoopBack2", "no", "bar"]
-    # Expected outputs:
-    #         [/LoopBack2/i, /no foo bar/, /zzz/i]
-    #
-    def token_str_to_regexp(token, args)
-      unless args[0].is_a? Hash
-        expected_args = token.join.scan(/%/).length
-        fail "Given #{args.length} args, but token #{token} requires " \
-          "#{expected_args}" unless args.length == expected_args
-      end
-      # replace all %s with *args
-      token.map! { |str| sprintf(str, *args.shift(str.scan(/%/).length)) }
-      # convert all to Regexp objects
-      token.map! do |str|
-        if str[-2..-1] == '/i'
-          Regexp.new(str[1..-3], Regexp::IGNORECASE)
-        else
-          Regexp.new(str[1..-2])
-        end
-      end
-      token
-    end
-
-    # Helper method to replace <> place holders in the config_get_token
-    # and config_get_token_append yaml entries.
-    #
-    # @param regexp [String][Array] regexp entry with <> placeholders
-    # @param values [Hash] Hash of named values to replace each <>
-    # @return [String]
-    def replace_token_ids(regexp, values)
-      final = replace_token_ids_string(regexp, values) if regexp.is_a?(String)
-      final = replace_token_ids_array(regexp, values) if regexp.is_a?(Array)
-      final
-    end
-
-    # @param regexp [String] regexp entry with <> placeholders
-    # @param values [Hash] Hash of named values to replace each <>
-    # @return [String]
-    def replace_token_ids_string(regexp, values)
-      replace = regexp.scan(/<(\S+)>/).flatten.map(&:to_sym)
-      replace.each do |item|
-        regexp = regexp.sub "<#{item}>",
-                            values[item].to_s if values.key?(item)
-      end
-      # Only return lines that actually replaced ids or did not have any
-      # ids to replace. Implicit nil returned if not.
-      return regexp if /<\S+>/.match(regexp).nil?
-    end
-
-    # @param regexp [Array] regexp entry with <> placeholders
-    # @param values [Hash] Hash of named values to replace each <>
-    # @return [String]
-    def replace_token_ids_array(regexp, values)
-      final_regexp = []
-      regexp.each do |line|
-        final_regexp.push(replace_token_ids_string(line, values))
-      end
-      final_regexp
-    end
-
-    # Helper method to build a multi-line config_get_token if
-    # the feature, name contains a config_get_token_append entry.
-    #
-    # @param feature [String]
-    # @param ref [CommandReference::CmdRef]
-    # @return [String, Array]
-    def build_config_get_token(feature, ref, args)
-      fail 'lazy_connect specified but did not request connect' unless @cmd_ref
-      # Why clone token? A bug in some ruby versions caused token to convert
-      # to type Regexp unexpectedly. The clone hard copy resolved it.
-
-      # If the options are presented as type Hash process as
-      # key-value replacement pairs
-      return ref.config_get_token.clone unless args[0].is_a?(Hash)
-      options = args[0]
-      token = []
-      # Use _template yaml entry if config_get_token_append
-      if ref.to_s[/config_get_token_append/]
-        # Get yaml feature template:
-        template = @cmd_ref.lookup(feature, '_template')
-        # Process config_get_token: from template:
-        token.push(replace_token_ids(template.config_get_token, options))
-        # Process config_get_token_append sequence: from template:
-        template.config_get_token_append.each do |line|
-          token.push(replace_token_ids(line, options))
-        end
-        # Add feature->property config_get_token append line
-        token.push(ref.config_get_token_append)
-      else
-        token.push(replace_token_ids(ref.config_get_token, options))
-      end
-      token.flatten!
-      token.compact!
-      token
-    end
-
-    # Helper method to use the feature, name config_get
-    # if present else use feature, "template" config_get
-    #
-    # @param feature [String]
-    # @param ref [CommandReference::CmdRef]
-    # @param type [Symbol]
-    # @return [String, Array]
-    def build_config_get(feature, ref, type)
-      fail 'lazy_connect specified but did not request connect' unless @cmd_ref
-      # Use feature name config_get string if present
-      # else use feature template: config_get
-      if ref.hash.key?('config_get')
-        return show(ref.config_get, type)
-      else
-        template = @cmd_ref.lookup(feature, '_template')
-        return show(template.config_get, type)
-      end
-    end
-
-    # Helper method to build a multi-line config_set if
-    # the feature, name contains a config_get_set_append
-    # yaml entry.
-    #
-    # @param feature [String]
-    # @param ref [CommandReference::CmdRef]
-    # @return [String, Array]
-    def build_config_set(feature, ref, args)
-      fail 'lazy_connect specified but did not request connect' unless @cmd_ref
-      # If the options are presented as type Hash process as
-      # key-value replacement pairs
-      return ref.config_set unless args[0].is_a?(Hash)
-      options = args[0]
-      config_set = []
-      # Use _template yaml entry if config_set_append
-      if ref.to_s[/config_set_append/]
-        # Get yaml feature template:
-        template = @cmd_ref.lookup(feature, '_template')
-        # Process config_set: from template:
-        config_set.push(replace_token_ids(template.config_set, options))
-        # Process config_set_append sequence: from template:
-        template.config_set_append.each do |line|
-          config_set.push(replace_token_ids(line, options))
-        end
-        # Add feature->property config_set append line
-        config_set.push(replace_token_ids(ref.config_set_append, options))
-      else
-        config_set.push(replace_token_ids(ref.config_set, options))
-      end
-      config_set.flatten!
-      config_set.compact!
-      config_set
-    end
-
     # Helper method for config_get().
     # @param token [Array, Hash] lookup sequence
     # @param result [Array, Hash] structured output from node
@@ -482,12 +322,7 @@ module Cisco
 
     # @return [String] such as "example.com"
     def domain_name
-      result = config_get('dnsclient', 'domain_name')
-      if result.nil?
-        return ''
-      else
-        return result[0]
-      end
+      config_get('dnsclient', 'domain_name')
     end
 
     # @return [Integer] System uptime, in seconds
@@ -495,7 +330,6 @@ module Cisco
       cache_flush
       t = config_get('show_system', 'uptime')
       fail 'failed to retrieve system uptime' if t.nil?
-      t = t.shift
       # time units: t = ["0", "23", "15", "49"]
       t.map!(&:to_i)
       d, h, m, s = t
@@ -504,12 +338,7 @@ module Cisco
 
     # @return [String] timestamp of last reset time
     def last_reset_time
-      output = config_get('show_version', 'last_reset_time')
-      return '' if output.nil?
-      # NX-OS may provide leading/trailing whitespace:
-      # " Sat Oct 25 00:39:25 2014\n"
-      # so be sure to strip() it down to the actual string.
-      output.strip
+      config_get('show_version', 'last_reset_time')
     end
 
     # @return [String] such as "Reset Requested by CLI command reload"
@@ -537,29 +366,6 @@ module Cisco
     end
   end
 
-  # Convenience wrapper for find_ascii. Operates under the assumption
-  # that there will be zero or one matches for the given query
-  # and returns the match string (or "") rather than an array.
-  #
-  # @raise [RuntimeError] if more than one match is found.
-  #
-  # @param body [String] The body of text to search
-  # @param regex_query [Regex] The regular expression to match
-  # @param parents [*Regex] zero or more regular expressions defining
-  #                the parent configs to filter by.
-  # @return [String] the matching (sub)string or "" if no match.
-  #
-  # @example Get the domain name if any
-  #   domain_name = find_one_ascii(running_cfg, "ip domain-name (.*)")
-  #   => 'example.com'
-  def find_one_ascii(body, regex_query, *parent_cfg)
-    matches = find_ascii(body, regex_query, *parent_cfg)
-    return '' if matches.nil?
-    fail RuntimeError if matches.length > 1
-    matches[0]
-  end
-  module_function :find_one_ascii
-
   # Method for working with hierarchical show command output such as
   # "show running-config". Searches the given multi-line string
   # for all matches to the given regex_query. If parents is provided,

data/lib/cisco_node_utils/node_util.rb

@@ -1,6 +1,6 @@
 # September 2015, Glenn F. Matthews
 #
-# Copyright (c) 2014-2015 Cisco and/or its affiliates.
+# Copyright (c) 2014-2016 Cisco and/or its affiliates.
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.
@@ -57,5 +57,9 @@ module Cisco
     def config_set(*args)
       node.config_set(*args)
     end
+
+    def show(*args)
+      node.show(*args)
+    end
   end
 end

data/lib/cisco_node_utils/ntp_config.rb

@@ -2,7 +2,7 @@
 #
 # Jonathan Tripathy et al., September 2015
 #
-# Copyright (c) 2014-2015 Cisco and/or its affiliates.
+# Copyright (c) 2014-2016 Cisco and/or its affiliates.
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.
@@ -43,7 +43,7 @@ module Cisco
 
     def source_interface
       source_interface = config_get('ntp_config', 'source_interface')
-      source_interface = source_interface[0].downcase \
+      source_interface = source_interface.downcase \
                           unless source_interface.nil?
       source_interface
     end

data/lib/cisco_node_utils/ntp_server.rb

@@ -2,7 +2,7 @@
 #
 # Jonathan Tripathy et al., September 2015
 #
-# Copyright (c) 2014-2015 Cisco and/or its affiliates.
+# Copyright (c) 2014-2016 Cisco and/or its affiliates.
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.
@@ -25,9 +25,19 @@ module Cisco
     def initialize(ntpserver_id, prefer, instantiate=true)
       @ntpserver_id = ntpserver_id.to_s
       @ntpserver_prefer = prefer
-      unless @ntpserver_id[/^(?:[0-9]{1,3}\.){3}[0-9]{1,3}$/]
-        fail ArgumentError, 'Invalid value(IP is not an IP address)'
+
+      unless @ntpserver_id =~ /^[a-zA-Z0-9\.\:]*$/
+        fail ArgumentError,
+             'Invalid value (IPv4/IPv6 address contains invalid characters)'
+      end
+
+      begin
+        IPAddr.new(@ntpserver_id)
+      rescue
+        raise ArgumentError,
+              'Invalid value (Name is not a valid single IPv4/IPv6 address)'
       end
+
       unless @ntpserver_prefer == true ||
              @ntpserver_prefer == false ||
              @ntpserver_prefer.nil?
@@ -39,10 +49,9 @@ module Cisco
     def self.ntpservers
       hash = {}
       ntpservers_list = config_get('ntp_server', 'server')
-      return hash if ntpservers_list.nil?
+      return hash if ntpservers_list.empty?
 
       preferred_servers = config_get('ntp_server', 'prefer')
-      preferred_servers = [] unless preferred_servers
 
       ntpservers_list.each do |id|
         hash[id] = NtpServer.new(id, preferred_servers.include?(id), false)