cisco_node_utils 1.0.1 → 1.1.0

data/lib/cisco_node_utils/interface_ospf.rb

@@ -1,6 +1,3 @@
-#
-# NXAPI implementation of Interface OSPF class
-#
 # March 2015, Alex Hunsberger
 #
 # Copyright (c) 2015 Cisco and/or its affiliates.
@@ -18,58 +15,56 @@
 # limitations under the License.
 
 require 'ipaddr'
-require File.join(File.dirname(__FILE__), 'node')
-require File.join(File.dirname(__FILE__), 'interface')
+require_relative 'node_util'
+require_relative 'interface'
 # Interestingly enough, interface OSPF configuration can exist completely
 # independent of router OSPF configuration... so we don't need RouterOspf here.
 
 module Cisco
-  class InterfaceOspf
+  # InterfaceOspf - node utility class for per-interface OSPF config management
+  class InterfaceOspf < NodeUtil
     attr_reader :interface, :ospf_name
 
-    @@node = Node.instance
-
     def initialize(int_name, ospf_name, area, create=true)
-      raise TypeError unless int_name.is_a? String
-      raise TypeError unless ospf_name.is_a? String
-      raise TypeError unless area.is_a? String
-      raise ArgumentError unless int_name.length > 0
-      raise ArgumentError unless ospf_name.length > 0
-      raise ArgumentError unless area.length > 0
+      fail TypeError unless int_name.is_a? String
+      fail TypeError unless ospf_name.is_a? String
+      fail TypeError unless area.is_a? String
+      fail ArgumentError unless int_name.length > 0
+      fail ArgumentError unless ospf_name.length > 0
+      fail ArgumentError unless area.length > 0
 
       # normalize
       int_name = int_name.downcase
       @interface = Interface.interfaces[int_name]
-      raise "interface #{int_name} does not exist" if @interface.nil?
+      fail "interface #{int_name} does not exist" if @interface.nil?
 
       @ospf_name = ospf_name
 
-      if create
-        # enable feature ospf if it isn't
-        RouterOspf.enable unless RouterOspf.enabled
+      return unless create
+      # enable feature ospf if it isn't
+      RouterOspf.enable unless RouterOspf.enabled
 
-        @@node.config_set("interface_ospf", "area", @interface.name,
-          "", @ospf_name, area)
-      end
+      config_set('interface_ospf', 'area', @interface.name,
+                 '', @ospf_name, area)
     end
 
     # can't re-use Interface.interfaces because we need to filter based on
     # "ip router ospf <name>", which Interface doesn't retrieve
-    def InterfaceOspf.interfaces(ospf_name=nil)
-      raise TypeError unless ospf_name.is_a? String or ospf_name.nil?
+    def self.interfaces(ospf_name=nil)
+      fail TypeError unless ospf_name.is_a?(String) || ospf_name.nil?
       ints = {}
 
-      intf_list = @@node.config_get("interface", "all_interfaces")
+      intf_list = config_get('interface', 'all_interfaces')
       return ints if intf_list.nil?
       intf_list.each do |name|
-        match = @@node.config_get("interface_ospf", "area", name)
+        match = config_get('interface_ospf', 'area', name)
         next if match.nil?
         # should only be a single match under a given interface
         match = match.first
         # ip router ospf <name> area <area>
         ospf = match[0]
         area = match[1]
-        next unless ospf_name.nil? or ospf == ospf_name
+        next unless ospf_name.nil? || ospf == ospf_name
         int = name.downcase
         ints[int] = InterfaceOspf.new(int, ospf, area, false)
       end
@@ -77,7 +72,7 @@ module Cisco
     end
 
     def area
-      match = @@node.config_get("interface_ospf", "area", @interface.name)
+      match = config_get('interface_ospf', 'area', @interface.name)
       return nil if match.nil?
       val = match[0][1]
       # Coerce numeric area to the expected dot-decimal format.
@@ -86,79 +81,81 @@ module Cisco
     end
 
     def area=(a)
-      @@node.config_set("interface_ospf", "area", @interface.name,
-        "", @ospf_name, a)
+      config_set('interface_ospf', 'area', @interface.name,
+                 '', @ospf_name, a)
     end
 
     def destroy
-      @@node.config_set("interface_ospf", "area", @interface.name,
-        "no", @ospf_name, area)
+      config_set('interface_ospf', 'area', @interface.name,
+                 'no', @ospf_name, area)
       # Reset everything else back to default as well:
       self.message_digest = default_message_digest
-      message_digest_key_set(default_message_digest_key_id, "", "", "")
+      message_digest_key_set(default_message_digest_key_id, '', '', '')
       self.cost = default_cost
       self.hello_interval = default_hello_interval
-      @@node.config_set("interface_ospf", "dead_interval",
-                        @interface.name, "no", "")
+      config_set('interface_ospf', 'dead_interval',
+                 @interface.name, 'no', '')
       self.passive_interface = default_passive_interface if passive_interface
     end
 
     def default_message_digest
-      @@node.config_get_default("interface_ospf", "message_digest")
+      config_get_default('interface_ospf', 'message_digest')
     end
 
     def message_digest
-      not @@node.config_get("interface_ospf", "message_digest",
-                            @interface.name).nil?
+      !config_get('interface_ospf', 'message_digest',
+                  @interface.name).nil?
     end
 
     # interface %s
     #   %s ip ospf authentication message-digest
     def message_digest=(enable)
-      @@node.config_set("interface_ospf", "message_digest", @interface.name,
-                        enable ? "" : "no")
+      config_set('interface_ospf', 'message_digest', @interface.name,
+                 enable ? '' : 'no')
     end
 
     def default_message_digest_key_id
-      @@node.config_get_default("interface_ospf", "message_digest_key_id")
+      config_get_default('interface_ospf', 'message_digest_key_id')
     end
 
     def message_digest_key_id
-      match = @@node.config_get("interface_ospf", "message_digest_key_id",
-                                @interface.name)
+      match = config_get('interface_ospf', 'message_digest_key_id',
+                         @interface.name)
       # regex in yaml returns an array result, use .first to get match
       match.nil? ? default_message_digest_key_id : match.first.to_i
     end
 
     def default_message_digest_algorithm_type
-      @@node.config_get_default("interface_ospf",
-                                "message_digest_alg_type").to_sym
+      config_get_default('interface_ospf',
+                         'message_digest_alg_type').to_sym
     end
 
     def message_digest_algorithm_type
-      match = @@node.config_get("interface_ospf", "message_digest_alg_type",
-                                @interface.name)
+      match = config_get('interface_ospf', 'message_digest_alg_type',
+                         @interface.name)
       # regex in yaml returns an array result, use .first to get match
-      match.nil? ? default_message_digest_algorithm_type :
-        match.first.to_sym
+      match.nil? ? default_message_digest_algorithm_type : match.first.to_sym
     end
 
     def default_message_digest_encryption_type
       Encryption.cli_to_symbol(
-        @@node.config_get_default("interface_ospf", "message_digest_enc_type"))
+        config_get_default('interface_ospf', 'message_digest_enc_type'))
     end
 
     def message_digest_encryption_type
-      match = @@node.config_get("interface_ospf", "message_digest_enc_type",
-                                @interface.name)
+      match = config_get('interface_ospf', 'message_digest_enc_type',
+                         @interface.name)
       # regex in yaml returns an array result, use .first to get match
-      match.nil? ? default_message_digest_encryption_type :
+      if match.nil?
+        default_message_digest_encryption_type
+      else
         Encryption.cli_to_symbol(match.first)
+      end
     end
 
     def message_digest_password
-      match = @@node.config_get("interface_ospf", "message_digest_password",
-                                @interface.name)
+      match = config_get('interface_ospf', 'message_digest_password',
+                         @interface.name)
       match.nil? ? nil : match.first
     end
 
@@ -167,89 +164,89 @@ module Cisco
     def message_digest_key_set(keyid, algtype, enctype, enc)
       current_keyid = message_digest_key_id
       if keyid == default_message_digest_key_id && current_keyid != keyid
-        @@node.config_set("interface_ospf", "message_digest_key_set",
-                          @interface.name, "no", current_keyid,
-                          "", "", "")
+        config_set('interface_ospf', 'message_digest_key_set',
+                   @interface.name, 'no', current_keyid,
+                   '', '', '')
       elsif keyid != default_message_digest_key_id
-        raise TypeError unless enc.is_a?(String)
-        raise ArgumentError unless enc.length > 0
+        fail TypeError unless enc.is_a?(String)
+        fail ArgumentError unless enc.length > 0
         enctype = Encryption.symbol_to_cli(enctype)
-        @@node.config_set("interface_ospf", "message_digest_key_set",
-                          @interface.name, "", keyid, algtype, enctype, enc)
+        config_set('interface_ospf', 'message_digest_key_set',
+                   @interface.name, '', keyid, algtype, enctype, enc)
       end
     end
 
     def cost
-      match = @@node.config_get("interface_ospf", "cost", @interface.name)
+      match = config_get('interface_ospf', 'cost', @interface.name)
       # regex in yaml returns an array result, use .first to get match
       match.nil? ? default_cost : match.first.to_i
     end
 
     def default_cost
-      @@node.config_get_default("interface_ospf", "cost")
+      config_get_default('interface_ospf', 'cost')
     end
 
     # interface %s
     #   ip ospf cost %d
     def cost=(c)
       if c == default_cost
-        @@node.config_set("interface_ospf", "cost", @interface.name, "no", "")
+        config_set('interface_ospf', 'cost', @interface.name, 'no', '')
       else
-        @@node.config_set("interface_ospf", "cost", @interface.name, "", c)
+        config_set('interface_ospf', 'cost', @interface.name, '', c)
       end
     end
 
     def hello_interval
-      match = @@node.config_get("interface_ospf", "hello_interval",
-                                @interface.name)
+      match = config_get('interface_ospf', 'hello_interval',
+                         @interface.name)
       # regex in yaml returns an array result, use .first to get match
       match.nil? ? default_hello_interval : match.first.to_i
     end
 
     def default_hello_interval
-      @@node.config_get_default("interface_ospf", "hello_interval")
+      config_get_default('interface_ospf', 'hello_interval')
     end
 
     # interface %s
     #   ip ospf hello-interval %d
     def hello_interval=(interval)
-      @@node.config_set("interface_ospf", "hello_interval",
-                        @interface.name, "", interval.to_i)
+      config_set('interface_ospf', 'hello_interval',
+                 @interface.name, '', interval.to_i)
     end
 
     def dead_interval
-      match = @@node.config_get("interface_ospf", "dead_interval",
-                                @interface.name)
+      match = config_get('interface_ospf', 'dead_interval',
+                         @interface.name)
       # regex in yaml returns an array result, use .first to get match
       match.nil? ? default_dead_interval : match.first.to_i
     end
 
     def default_dead_interval
-      @@node.config_get_default("interface_ospf", "dead_interval")
+      config_get_default('interface_ospf', 'dead_interval')
     end
 
     # interface %s
     #   ip ospf dead-interval %d
     def dead_interval=(interval)
-      @@node.config_set("interface_ospf", "dead_interval",
-                        @interface.name, "", interval.to_i)
+      config_set('interface_ospf', 'dead_interval',
+                 @interface.name, '', interval.to_i)
     end
 
     def default_passive_interface
-      @@node.config_get_default("interface_ospf", "passive_interface")
+      config_get_default('interface_ospf', 'passive_interface')
     end
 
     def passive_interface
-      not @@node.config_get("interface_ospf", "passive_interface",
-                            @interface.name).nil?
+      !config_get('interface_ospf', 'passive_interface',
+                  @interface.name).nil?
     end
 
     # interface %s
     #   %s ip ospf passive-interface
     def passive_interface=(enable)
-      raise TypeError unless enable == true or enable == false
-      @@node.config_set("interface_ospf", "passive_interface", @interface.name,
-                        enable ? "" : "no")
+      fail TypeError unless enable == true || enable == false
+      config_set('interface_ospf', 'passive_interface', @interface.name,
+                 enable ? '' : 'no')
     end
   end
 end

data/lib/cisco_node_utils/name_server.rb

@@ -0,0 +1,64 @@
+#
+# NXAPI implementation of NameServer class
+#
+# September 2015, Hunter Haugen
+#
+# Copyright (c) 2015 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.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+# "group" is a standard SNMP term but in NXOS "role" is used to serve the
+# purpose of group; thus this provider utility does not create snmp groups
+# and is limited to reporting group (role) existence only.
+
+require_relative 'node_util'
+
+module Cisco
+  # NameServer - node utility class for DNS client name server config management
+  class NameServer < NodeUtil
+    attr_reader :name
+
+    def initialize(name, instantiate=true)
+      unless name.is_a? String
+        fail TypeError, "Expected a string, got a #{name.inspect}"
+      end
+      @name = name
+      create if instantiate
+    end
+
+    def self.nameservers
+      hosts = config_get('dnsclient', 'name_server')
+      return {} if hosts.nil?
+
+      hash = {}
+      # Join and split because config_get returns array of strings separated by
+      # spaces (regexes are a subset of PDA)
+      hosts.join(' ').split(' ').each do |name|
+        hash[name] = NameServer.new(name, false)
+      end
+      hash
+    end
+
+    def ==(other)
+      name == other.name
+    end
+
+    def create
+      config_set('dnsclient', 'name_server', state: '', ip: @name)
+    end
+
+    def destroy
+      config_set('dnsclient', 'name_server', state: 'no', ip: @name)
+    end
+  end
+end

data/lib/cisco_node_utils/node.rb

@@ -21,8 +21,9 @@
 require 'singleton'
 
 require 'cisco_nxapi'
-require File.join(File.dirname(__FILE__), 'command_reference')
+require_relative 'command_reference'
 
+# Add node management classes and APIs to the Cisco namespace.
 module Cisco
   # Error class raised by the config_set and config_get APIs if the
   # device encounters an issue trying to act on the requested CLI.
@@ -33,7 +34,7 @@ module Cisco
     attr_reader :command, :clierror, :previous
     def initialize(command, clierror, previous)
       @command = command
-      @clierror = clierror.rstrip
+      @clierror = clierror.rstrip if clierror.kind_of? String
       @previous = previous
     end
 
@@ -46,7 +47,6 @@ module Cisco
   # Singleton representing the network node (switch/router) that is
   # running this code. The singleton is lazily instantiated, meaning that
   # it doesn't exist until some client requests it (with Node.instance())
-
   class Node
     include Singleton
 
@@ -61,14 +61,54 @@ module Cisco
     #
     # @raise [IndexError] if the given (feature, name) pair is not in the
     #        CommandReference data or if the data doesn't have values defined
-    #        for the 'config_get' and 'config_get_token' fields.
+    #        for the 'config_get' and (optional) 'config_get_token' fields.
     # @raise [Cisco::CliError] if the given command is rejected by the device.
     #
     # @param feature [String]
     # @param name [String]
-    # @return [String]
+    # @return [String, Hash, Array]
     # @example config_get("show_version", "system_image")
-    def config_get(feature, name)
+    # @example config_get("ospf", "router_id",
+    #                      {: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)
+
+      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 = 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])
+
+        else
+          result = build_config_get(feature, ref, :structured)
+          return config_get_handle_structured(token, result)
+        end
+      elsif token.nil?
+        return show(ref.config_get, :structured)
+      end
+      fail TypeError("Unclear to handle config_get_token #{token}")
     end
 
     # Uses CommandReference to lookup the default value for a given
@@ -82,6 +122,9 @@ module Cisco
     # @return [String]
     # @example config_get_default("vtp", "file")
     def config_get_default(feature, name)
+      fail 'lazy_connect specified but did not request connect' unless @cmd_ref
+      ref = @cmd_ref.lookup(feature, name)
+      ref.default_value
     end
 
     # Uses CommandReference to look up the given config command(s) of interest
@@ -95,7 +138,37 @@ module Cisco
     # @param name [String]
     # @param args [*String] zero or more args to be substituted into the cmdref.
     # @example config_set("vtp", "domain", "example.com")
+    # @example config_set("ospf", "router_id",
+    #  {:name => "green", :vrf => "one", :state => "",
+    #   :router_id => "192.0.0.1"})
     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
     end
 
     # Clear the cache of CLI output results.
@@ -104,25 +177,29 @@ module Cisco
     # whenever a config_set() is called, but providers may also call this
     # to explicitly force the cache to be cleared.
     def cache_flush
+      @client.cache_flush
     end
 
-    # END NODE API
     # Here and below are implementation details and private APIs that most
     # providers shouldn't need to know about or use.
 
     attr_reader :cmd_ref, :client
 
     # For unit testing - we won't know the node connection info at load time.
-    @@lazy_connect = false
+    @lazy_connect = false
+
+    class << self
+      attr_reader :lazy_connect
+    end
 
-    def Node.lazy_connect=(val)
-      @@lazy_connect = val
+    class << self
+      attr_writer :lazy_connect
     end
 
     def initialize
       @client = nil
       @cmd_ref = nil
-      connect unless @@lazy_connect
+      connect unless self.class.lazy_connect
     end
 
     def to_s
@@ -141,13 +218,6 @@ module Cisco
       @client.reload
     end
 
-    # hidden as well
-    attr_reader :client
-
-    def cache_flush
-      @client.cache_flush
-    end
-
     def cache_enable?
       @client.cache_enable?
     end
@@ -175,19 +245,19 @@ module Cisco
     def token_str_to_regexp(token, args)
       unless args[0].is_a? Hash
         expected_args = token.join.scan(/%/).length
-        raise "Given #{args.length} args, but token #{token} requires " +
+        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! { |str|
+      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
 
@@ -210,7 +280,7 @@ module Cisco
       replace = regexp.scan(/<(\S+)>/).flatten.map(&:to_sym)
       replace.each do |item|
         regexp = regexp.sub "<#{item}>",
-          values[item].to_s if values.key?(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.
@@ -235,7 +305,7 @@ module Cisco
     # @param ref [CommandReference::CmdRef]
     # @return [String, Array]
     def build_config_get_token(feature, ref, args)
-      raise "lazy_connect specified but did not request connect" unless @cmd_ref
+      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.
 
@@ -247,7 +317,7 @@ module Cisco
       # 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")
+        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:
@@ -272,13 +342,13 @@ module Cisco
     # @param type [Symbol]
     # @return [String, Array]
     def build_config_get(feature, ref, type)
-      raise "lazy_connect specified but did not request connect" unless @cmd_ref
+      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")
+      if ref.hash.key?('config_get')
         return show(ref.config_get, type)
       else
-        template = @cmd_ref.lookup(feature, "_template")
+        template = @cmd_ref.lookup(feature, '_template')
         return show(template.config_get, type)
       end
     end
@@ -291,7 +361,7 @@ module Cisco
     # @param ref [CommandReference::CmdRef]
     # @return [String, Array]
     def build_config_set(feature, ref, args)
-      raise "lazy_connect specified but did not request connect" unless @cmd_ref
+      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)
@@ -300,7 +370,7 @@ module Cisco
       # 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")
+        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:
@@ -317,146 +387,31 @@ module Cisco
       config_set
     end
 
-    # 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
-    # to that key.
-    #
-    # @raise [IndexError] if the given (feature, name) pair is not in the
-    #        CommandReference data or if the data doesn't have values defined
-    #        for the 'config_get' and (optional) 'config_get_token' fields.
-    # @raise [Cisco::CliError] if the given command is rejected by the device.
-    #
-    # @param feature [String]
-    # @param name [String]
-    # @return [String, Hash, Array]
-    # @example config_get("show_version", "system_image")
-    # @example config_get("ospf", "router_id",
-    #                      {:name => "green", :vrf => "one"})
-    def config_get(feature, name, *args)
-      raise "lazy_connect specified but did not request connect" unless @cmd_ref
-      ref = @cmd_ref.lookup(feature, name)
-
-      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 = nil
-      end
-      if token.kind_of?(String) and token[0] == '/' and token[-1] == '/'
-        raise 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)
-      elsif token.kind_of?(String)
-        hash = build_config_get(feature, ref, :structured)
-        return hash[token]
-
-      elsif token.kind_of?(Array)
-        # Array of /regexps/ -> ascii, array of strings/ints -> structured
-        if token[0].kind_of?(String) and
-           token[0][0] == '/' and
-           (token[0][-1] == '/' or 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])
-
-        else
-          result = build_config_get(feature, ref, :structured)
-          begin
-            token.each do |token|
-              # if token is a hash and result is an array, check each
-              # array index (which should return another hash) to see if
-              # it contains the matching key/value pairs specified in token,
-              # and return the first match (or nil)
-              if token.kind_of?(Hash)
-                raise "Expected array, got #{result.class}" unless result.kind_of?(Array)
-                result = result.select { |x| token.all? { |k, v| x[k] == v } }
-                raise "Multiple matches found for #{token}" if result.length > 1
-                raise "No match found for #{token}" if result.length == 0
-                result = result[0]
-              else # result is array or hash
-                raise "No key \"#{token}\" in #{result}" if result[token].nil?
-                result = result[token]
-              end
-            end
-            return result
-          rescue Exception => e
-            # TODO: logging user story, Syslog isn't available here
-            # Syslog.debug(e.message)
-            return nil
-          end
-        end
-      elsif token.nil?
-        return show(ref.config_get, :structured)
-      end
-      raise TypeError("Unclear to handle config_get_token #{token}")
-    end
-
-    # Uses CommandReference to lookup the default value for a given
-    # feature and feature property.
-    #
-    # @raise [IndexError] if the given (feature, name) pair is not in the
-    #        CommandReference data or if the data doesn't have values defined
-    #        for the 'default_value' field.
-    # @param feature [String]
-    # @param name [String]
-    # @return [String]
-    # @example config_get_default("vtp", "file")
-    def config_get_default(feature, name)
-      raise "lazy_connect specified but did not request connect" unless @cmd_ref
-      ref = @cmd_ref.lookup(feature, name)
-      ref.default_value
-    end
-
-    # Uses CommandReference to look up the given config command(s) of interest
-    # and then applies the configuration.
-    #
-    # @raise [IndexError] if no relevant cmd_ref config_set exists
-    # @raise [ArgumentError] if too many or too few args are provided.
-    # @raise [Cisco::CliError] if any command is rejected by the device.
-    #
-    # @param feature [String]
-    # @param name [String]
-    # @param args [*String] zero or more args to be substituted into the cmdref.
-    # @example config_set("vtp", "domain", "example.com")
-    # @example config_set("ospf", "router_id",
-    #  {:name => "green", :vrf => "one", :state => "",
-    #   :router_id => "192.0.0.1"})
-    def config_set(feature, name, *args)
-      raise "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
-        raise TypeError, "%{config_set.class} not supported for config_set"
-      end
-      unless args[0].is_a? Hash
-        if param_count != args.length
-          raise ArgumentError.new("Wrong number of params - expected: " +
-                                "#{param_count} actual: #{args.length}")
+    # Helper method for config_get().
+    # @param token [Array, Hash] lookup sequence
+    # @param result [Array, Hash] structured output from node
+    def config_get_handle_structured(token, result)
+      token.each do |t|
+        # if token is a hash and result is an array, check each
+        # array index (which should return another hash) to see if
+        # it contains the matching key/value pairs specified in token,
+        # and return the first match (or nil)
+        if t.kind_of?(Hash)
+          fail "Expected array, got #{result.class}" unless result.is_a? Array
+          result = result.select { |x| t.all? { |k, v| x[k] == v } }
+          fail "Multiple matches found for #{t}" if result.length > 1
+          fail "No match found for #{t}" if result.length == 0
+          result = result[0]
+        else # result is array or hash
+          fail "No key \"#{t}\" in #{result}" if result[t].nil?
+          result = result[t]
         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
-          if param_count > 0
-            new_config_set << sprintf(line, *args)
-            args = args[param_count..-1]
-          else
-            new_config_set << line
-          end
-        end
-        config(new_config_set)
-      end
+      result
+    rescue RuntimeError
+      # TODO: logging user story, Syslog isn't available here
+      # Syslog.debug(e.message)
+      nil
     end
 
     # Send a config command to the device.
@@ -465,6 +420,7 @@ module Cisco
     #
     # @raise [Cisco::CliError] if any command is rejected by the device.
     def config(commands)
+      CiscoLogger.debug("CLI Sent to device: #{commands}")
       @client.config(commands)
     rescue CiscoNxapi::CliError => e
       raise Cisco::CliError.new(e.input, e.clierror, e.previous)
@@ -483,52 +439,52 @@ module Cisco
 
     # @return [String] such as "Cisco Nexus Operating System (NX-OS) Software"
     def os
-       o = config_get("show_version", "header")
-       raise "failed to retrieve operating system information" if o.nil?
-       o.split("\n")[0]
+      o = config_get('show_version', 'header')
+      fail 'failed to retrieve operating system information' if o.nil?
+      o.split("\n")[0]
     end
 
     # @return [String] such as "6.0(2)U5(1) [build 6.0(2)U5(0.941)]"
     def os_version
-      config_get("show_version", "version")
+      config_get('show_version', 'version')
     end
 
     # @return [String] such as "Nexus 3048 Chassis"
     def product_description
-      config_get("show_version", "description")
+      config_get('show_version', 'description')
     end
 
     # @return [String] such as "N3K-C3048TP-1GE"
     def product_id
       if @cmd_ref
-        return config_get("inventory", "productid")
+        return config_get('inventory', 'productid')
       else
         # We use this function to *find* the appropriate CommandReference
-        entries = show("show inventory", :structured)
-        return entries["TABLE_inv"]["ROW_inv"][0]["productid"]
+        entries = show('show inventory', :structured)
+        return entries['TABLE_inv']['ROW_inv'][0]['productid']
       end
     end
 
     # @return [String] such as "V01"
     def product_version_id
-      config_get("inventory", "versionid")
+      config_get('inventory', 'versionid')
     end
 
     # @return [String] such as "FOC1722R0ET"
     def product_serial_number
-      config_get("inventory", "serialnum")
+      config_get('inventory', 'serialnum')
     end
 
     # @return [String] such as "bxb-oa-n3k-7"
     def host_name
-      config_get("show_version", "host_name")
+      config_get('show_version', 'host_name')
     end
 
     # @return [String] such as "example.com"
     def domain_name
-      result = config_get("domain_name", "domain_name")
+      result = config_get('dnsclient', 'domain_name')
       if result.nil?
-        return ""
+        return ''
       else
         return result[0]
       end
@@ -537,8 +493,8 @@ module Cisco
     # @return [Integer] System uptime, in seconds
     def system_uptime
       cache_flush
-      t = config_get("show_system", "uptime")
-      raise "failed to retrieve system uptime" if t.nil?
+      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)
@@ -548,8 +504,8 @@ 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?
+      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.
@@ -558,26 +514,26 @@ module Cisco
 
     # @return [String] such as "Reset Requested by CLI command reload"
     def last_reset_reason
-      config_get("show_version", "last_reset_reason")
+      config_get('show_version', 'last_reset_reason')
     end
 
     # @return [Float] combined user/kernel CPU utilization
     def system_cpu_utilization
-      output = config_get("system", "resources")
-      raise "failed to retrieve cpu utilization" if output.nil?
-      output["cpu_state_user"].to_f + output["cpu_state_kernel"].to_f
+      output = config_get('system', 'resources')
+      fail 'failed to retrieve cpu utilization' if output.nil?
+      output['cpu_state_user'].to_f + output['cpu_state_kernel'].to_f
     end
 
     # @return [String] such as
     #   "bootflash:///n3000-uk9-kickstart.6.0.2.U5.0.941.bin"
     def boot
-      config_get("show_version", "boot_image")
+      config_get('show_version', 'boot_image')
     end
 
     # @return [String] such as
     #   "bootflash:///n3000-uk9.6.0.2.U5.0.941.bin"
     def system
-      config_get("show_version", "system_image")
+      config_get('show_version', 'system_image')
     end
   end
 
@@ -598,8 +554,8 @@ module Cisco
   #   => 'example.com'
   def find_one_ascii(body, regex_query, *parent_cfg)
     matches = find_ascii(body, regex_query, *parent_cfg)
-    return "" if matches.nil?
-    raise RuntimeError if matches.length > 1
+    return '' if matches.nil?
+    fail RuntimeError if matches.length > 1
     matches[0]
   end
   module_function :find_one_ascii
@@ -623,11 +579,11 @@ module Cisco
   #   bgp_afs = find_ascii(show_run_bgp, /^address-family (.*)/,
   #                        /^router bgp #{ASN}/)
   def find_ascii(body, regex_query, *parent_cfg)
-    return nil if body.nil? or regex_query.nil?
+    return nil if body.nil? || regex_query.nil?
 
     # get subconfig
     parent_cfg.each { |p| body = find_subconfig(body, p) }
-    if body.nil?
+    if body.nil? || body.empty?
       return nil
     else
       # find matches and return as array of String if it only does one
@@ -635,7 +591,7 @@ module Cisco
       match = body.split("\n").map { |s| s.scan(regex_query) }
       match = match.flatten(1)
       return nil if match.empty?
-      match = match.flatten if match[0].is_a?(Array) and match[0].length == 1
+      match = match.flatten if match[0].is_a?(Array) && match[0].length == 1
       return match
     end
   end
@@ -649,16 +605,16 @@ module Cisco
   # @return [String, nil] the subsection of body, de-indented
   # appropriately, or nil if no such subsection exists.
   def find_subconfig(body, regex_query)
-    return nil if body.nil? or regex_query.nil?
+    return nil if body.nil? || regex_query.nil?
 
     rows = body.split("\n")
     match_row_index = rows.index { |row| regex_query =~ row }
     return nil if match_row_index.nil?
 
-    cur = match_row_index+1
+    cur = match_row_index + 1
     subconfig = []
 
-    until (/\A\s+.*/ =~ rows[cur]).nil? or cur == rows.length
+    until (/\A\s+.*/ =~ rows[cur]).nil? || cur == rows.length
       subconfig << rows[cur]
       cur += 1
     end