cisco_node_utils 1.2.0 → 1.3.0

data/lib/cisco_node_utils/vtp.rb

@@ -15,6 +15,7 @@
 # limitations under the License.
 
 require_relative 'node_util'
+require_relative 'logger'
 
 module Cisco
   # Vtp - node utility class for VTP configuration management
@@ -26,29 +27,22 @@ module Cisco
 
     # Constructor for Vtp
     def initialize(instantiate=true)
-      enable if instantiate && !Vtp.enabled
+      Feature.vtp_enable if instantiate
     end
 
-    def self.enabled
-      config_get('vtp', 'feature')
-    rescue Cisco::CliError => e
-      # cmd will syntax reject when feature is not enabled
-      raise unless e.clierror =~ /Syntax error/
-      return false
-    end
-
-    def enable
-      config_set('vtp', 'feature', '')
+    # Get vtp domain name
+    def self.domain
+      if Feature.vtp_enabled?
+        config_get('vtp', 'domain')
+      else
+        config_get_default('vtp', 'domain')
+      end
     end
 
-    # Disable vtp feature
+    # The only way to remove a vtp domain is to turn the vtp
+    # feature off.
     def destroy
-      config_set('vtp', 'feature', 'no')
-    end
-
-    # Get vtp domain name
-    def self.domain
-      enabled ? config_get('vtp', 'domain') : ''
+      Feature.vtp_disable
     end
 
     def domain
@@ -57,23 +51,22 @@ module Cisco
 
     # Set vtp domain name
     def domain=(d)
-      fail ArgumentError unless d && d.is_a?(String) &&
-                                d.length.between?(1, MAX_VTP_DOMAIN_NAME_SIZE)
-      enable unless Vtp.enabled
-      begin
-        config_set('vtp', 'domain', d)
-      rescue Cisco::CliError => e
-        # cmd will syntax reject when setting name to same name
-        raise unless e.clierror =~ /ERROR: Domain name already set to /
-      end
+      d = d.to_s
+      fail ArgumentError unless d.length.between?(1, MAX_VTP_DOMAIN_NAME_SIZE)
+      config_set('vtp', 'domain', domain: d)
     end
 
     # Get vtp password
     def password
       # Unfortunately nxapi returns "\\" when the password is not set
-      password = config_get('vtp', 'password') if Vtp.enabled
+      password = config_get('vtp', 'password') if Feature.vtp_enabled?
       return '' if password.nil? || password == '\\'
       password
+    rescue Cisco::RequestNotSupported => e
+      # Certain platforms generate a Cisco::RequestNotSupported when the
+      # vtp password is not set.  We catch this specific error and
+      # return empty '' for the password.
+      return '' if e.message[/Structured output not supported/]
     end
 
     # Set vtp password
@@ -81,19 +74,9 @@ module Cisco
       fail TypeError if password.nil?
       fail TypeError unless password.is_a? String
       fail ArgumentError if password.length > MAX_VTP_PASSWORD_SIZE
-      enable unless Vtp.enabled
-      begin
-        if password == default_password
-          config_set('vtp', 'password', 'no', '')
-        else
-          config_set('vtp', 'password', '', password)
-        end
-      rescue Cisco::CliError => e
-        raise unless e.clierror =~ /password cannot be set for NULL domain/
-        unless password == default_password
-          raise 'Setting VTP password requires first setting VTP domain'
-        end
-      end
+      Feature.vtp_enable
+      state = (password == default_password) ? 'no' : ''
+      config_set('vtp', 'password', state: state, password: password)
     end
 
     # Get default vtp password
@@ -103,18 +86,17 @@ module Cisco
 
     # Get vtp filename
     def filename
-      config_get('vtp', 'filename')
+      filename = config_get('vtp', 'filename') if Feature.vtp_enabled?
+      filename.nil? ? default_filename : filename
     end
 
     # Set vtp filename
     def filename=(uri)
       fail TypeError if uri.nil?
-      enable unless Vtp.enabled
-      if uri.empty?
-        config_set('vtp', 'filename', 'no', '')
-      else
-        config_set('vtp', 'filename', '', uri)
-      end
+      Feature.vtp_enable
+      uri = uri.to_s
+      state = uri.empty? ? 'no' : ''
+      config_set('vtp', 'filename', state: state, uri: uri)
     end
 
     # Get default vtp filename
@@ -124,13 +106,13 @@ module Cisco
 
     # Get vtp version
     def version
-      Vtp.enabled ? config_get('vtp', 'version') : default_version
+      Feature.vtp_enabled? ? config_get('vtp', 'version') : default_version
     end
 
     # Set vtp version
-    def version=(version)
-      enable unless Vtp.enabled
-      config_set('vtp', 'version', "#{version}")
+    def version=(v)
+      Feature.vtp_enable
+      config_set('vtp', 'version', version: v)
     end
 
     # Get default vtp version

data/lib/cisco_node_utils/vxlan_vtep.rb

@@ -55,15 +55,19 @@ module Cisco
     end
 
     def create
+      if FabricpathGlobal.fabricpath_feature == :enabled &&
+         node.product_id[/N(5|6)K/]
+        fail 'VxLAN cannot be enabled with Fabricpath configured'
+      end
       Feature.nv_overlay_enable
       Feature.vn_segment_vlan_based_enable if VxlanVtep.mt_lite_support
       # re-use the "interface command ref hooks"
-      config_set('interface', 'create', @name)
+      config_set('interface', 'create', name: @name)
     end
 
     def destroy
       # re-use the "interface command ref hooks"
-      config_set('interface', 'destroy', @name)
+      config_set('interface', 'destroy', name: @name)
     end
 
     def ==(other)
@@ -75,16 +79,14 @@ module Cisco
     ########################################################
 
     def description
-      config_get('interface', 'description', @name)
+      config_get('interface', 'description', name: @name)
     end
 
     def description=(desc)
       fail TypeError unless desc.is_a?(String)
-      if desc.empty?
-        config_set('interface', 'description', @name, 'no', '')
-      else
-        config_set('interface', 'description', @name, '', desc)
-      end
+      state = desc.empty? ? 'no' : ''
+      config_set('interface', 'description',
+                 name: @name, state: state, desc: desc)
     end
 
     def default_description
@@ -135,6 +137,30 @@ module Cisco
       config_get_default('vxlan_vtep', 'source_intf')
     end
 
+    def source_interface_hold_down_time
+      config_get('vxlan_vtep', 'source_intf_hold_down_time', name: @name)
+    end
+
+    def source_interface_hold_down_time=(time)
+      state = time == default_source_interface_hold_down_time ? 'no' : ''
+      # Cli rejects removing hold-down-time without an argument, so make
+      # sure it is configured before attempting to remove it
+      if state == 'no'
+        time = source_interface_hold_down_time
+        unless time == default_source_interface_hold_down_time
+          config_set('vxlan_vtep', 'source_intf_hold_down_time', name: @name,
+                             state: state, time: time)
+        end
+      else
+        config_set('vxlan_vtep', 'source_intf_hold_down_time', name: @name,
+                               state: state, time: time)
+      end
+    end
+
+    def default_source_interface_hold_down_time
+      config_get_default('vxlan_vtep', 'source_intf_hold_down_time')
+    end
+
     def shutdown
       config_get('vxlan_vtep', 'shutdown', name: @name)
     end

data/lib/cisco_node_utils/vxlan_vtep_vni.rb

@@ -104,12 +104,18 @@ module Cisco
     #                      PROPERTIES                      #
     ########################################################
 
+    def ingress_replication_supported?
+      node.cmd_ref.supports?('vxlan_vtep_vni', 'ingress_replication')
+    end
+
     def ingress_replication
       config_get('vxlan_vtep_vni', 'ingress_replication', @get_args)
     end
 
     def remove_add_ingress_replication(protocol)
-      if ingress_replication.empty?
+      # Note: ingress-replication is not supported on all platforms.
+      # Use to_s.empty check to also handle nil check.
+      if ingress_replication.to_s.empty?
         set_args_keys(state: '', protocol: protocol)
         config_set('vxlan_vtep_vni', 'ingress_replication', @set_args)
       else
@@ -171,7 +177,7 @@ module Cisco
         ip_end = '' if ip_end.nil?
         # Since multicast group and ingress replication are exclusive
         # properties, remove ingress replication first
-        unless ingress_replication.empty?
+        if ingress_replication_supported? && !ingress_replication.empty?
           set_args_keys(state: 'no', protocol: ingress_replication)
           config_set('vxlan_vtep_vni', 'ingress_replication', @set_args)
         end
@@ -191,7 +197,7 @@ module Cisco
       delta_hash = Utils.delta_add_remove(should_list, peer_list)
       return if delta_hash.values.flatten.empty?
       [:add, :remove].each do |action|
-        CiscoLogger.debug('peer_list' \
+        Cisco::Logger.debug('peer_list' \
           "#{@get_args}\n #{action}: #{delta_hash[action]}")
         delta_hash[action].each do |peer|
           state = (action == :add) ? '' : 'no'
@@ -214,7 +220,9 @@ module Cisco
       if state
         set_args_keys(state: '')
         # Host reachability must be enabled for this property
-        VxlanVtep.new(@name).host_reachability = 'evpn'
+        unless VxlanVtep.new(@name).host_reachability == 'evpn'
+          fail "Dependency: vxlan_vtep host_reachability must be 'evpn'."
+        end
         config_set('vxlan_vtep_vni', 'suppress_arp', @set_args)
       else
         set_args_keys(state: 'no')
@@ -230,5 +238,29 @@ module Cisco
     def default_suppress_arp
       config_get_default('vxlan_vtep_vni', 'suppress_arp')
     end
+
+    def suppress_uuc
+      config_get('vxlan_vtep_vni', 'suppress_uuc', @get_args)
+    end
+
+    def suppress_uuc=(state)
+      if state
+        set_args_keys(state: '')
+        # Host reachability must be enabled for this property
+        unless VxlanVtep.new(@name).host_reachability == 'evpn'
+          fail "Dependency: vxlan_vtep host_reachability must be 'evpn'"
+        end
+        config_set('vxlan_vtep_vni', 'suppress_uuc', @set_args)
+      else
+        set_args_keys(state: 'no')
+        # Remove suppress-uuc only if it is configured. Note that for
+        # suppress-uuc, default is 'false' which is no suppress-uuc.
+        config_set('vxlan_vtep_vni', 'suppress_uuc', @set_args) if suppress_uuc
+      end
+    end
+
+    def default_suppress_uuc
+      config_get_default('vxlan_vtep_vni', 'suppress_uuc')
+    end
   end
 end

data/lib/minitest/environment_plugin.rb

@@ -0,0 +1,31 @@
+# March 2016, Glenn F. Matthews
+#
+# Copyright (c) 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.
+# 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.
+
+require_relative '../cisco_node_utils/environment'
+
+# Add environment option to minitest
+module Minitest
+  def self.plugin_environment_options(opts, options)
+    opts.on('-e', '--environment NAME', 'Select environment by name') do |name|
+      options[:environment] = name
+    end
+  end
+
+  def self.plugin_environment_init(options)
+    name = options[:environment]
+    Cisco::Environment.default_environment_name = name unless name.nil?
+  end
+end

data/lib/minitest/log_level_plugin.rb

@@ -0,0 +1,41 @@
+# March 2016, Glenn F. Matthews
+#
+# Copyright (c) 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.
+# 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.
+
+require 'logger'
+require_relative '../cisco_node_utils/logger'
+
+# Add logging level option to minitest
+module Minitest
+  LEVEL_ALIASES = {
+    'debug'   => Logger::DEBUG,
+    'info'    => Logger::INFO,
+    'warning' => Logger::WARN,
+    'error'   => Logger::ERROR,
+  }
+  def self.plugin_log_level_options(opts, options)
+    opts.on(
+      '-l', '--log-level LEVEL', LEVEL_ALIASES,
+      'Configure logging level for tests',
+      "(#{LEVEL_ALIASES.keys.join(', ')})"
+    ) do |level|
+      options[:log_level] = level
+    end
+  end
+
+  def self.plugin_log_level_init(options)
+    Cisco::Logger.level = options[:log_level] if options[:log_level]
+  end
+end

data/spec/client_spec.rb

@@ -0,0 +1,7 @@
+require_relative 'spec_helper.rb'
+require 'shared_examples_for_clients'
+require 'cisco_node_utils/client'
+
+describe Cisco::Client do
+  it_behaves_like 'all clients'
+end

data/spec/environment_spec.rb

@@ -0,0 +1,263 @@
+require_relative 'spec_helper.rb'
+require 'cisco_node_utils/environment'
+require 'cisco_node_utils/client'
+
+class << Cisco::Environment
+  attr_writer :environments
+end
+
+describe Cisco::Environment do
+  after(:each) do
+    # Revert to default environment data
+    Cisco::Environment.environments = {}
+  end
+
+  describe '.data_from_file' do
+    it 'handles File.expand_path errors' do
+      expect(File).to receive(:expand_path).and_raise(ArgumentError)
+      expect(Cisco::Environment.data_from_file('~/foo/bar.yaml')).to be_empty
+    end
+
+    it 'handles nonexistent files' do
+      expect(File).to receive(:file?).and_return(false)
+      expect(Cisco::Environment.data_from_file('/foo/bar.yaml')).to be_empty
+    end
+
+    it 'handles unreadable files' do
+      expect(File).to receive(:file?).and_return(true)
+      expect(File).to receive(:readable?).and_return(false)
+      expect(Cisco::Environment.data_from_file('/foo/bar.yaml')).to be_empty
+    end
+
+    it 'handles YAML errors' do
+      expect(File).to receive(:file?).and_return(true)
+      expect(File).to receive(:readable?).and_return(true)
+      error = Psych::SyntaxError.new('/foo/bar.yaml', 1, 1, 0, 'foo', 'bar')
+      expect(YAML).to receive(:load_file).and_raise(error)
+      # Catch the error log message Environment will generate:
+      expect(Cisco::Logger).to receive(:error).once
+      expect(Cisco::Environment.data_from_file('/foo/bar.yaml')).to eq({})
+    end
+  end
+
+  describe '.merge_config' do
+    it 'merges valid content' do
+      base = { 'hello' => {
+        host:     '2.2.2.2',
+        port:     57_799,
+        username: nil,
+        password: nil,
+      } }
+      expect(Cisco::Environment).to receive(:data_from_file).and_return(
+        'hello' => { host: '1.1.1.1' }, 'goodbye' => { password: 'foo' })
+      expect(Cisco::Environment.merge_config('/foo/bar.yaml', base)).to eq(
+        'hello'   => {
+          host:     '1.1.1.1',
+          port:     57_799,
+          username: nil,
+          password: nil,
+        },
+        'goodbye' => {
+          host:     nil,
+          port:     nil,
+          username: nil,
+          password: 'foo',
+        },
+      )
+    end
+  end
+
+  describe '.environments' do
+    before(:each) do
+      allow(Cisco::Environment).to receive(:data_from_file).and_return({})
+    end
+
+    it 'is empty by default' do
+      expect(Cisco::Environment.environments).to be_empty
+    end
+
+    global_config = {
+      'default' => {
+        host: '127.0.0.1',
+        port: 57_400,
+      },
+      'global'  => {
+        username: 'global',
+        password: 'global',
+      },
+    }
+
+    user_config = {
+      'default' => {
+        port:     57_799,
+        username: 'user',
+      },
+      'user'    => {
+        username: 'user',
+        password: 'user',
+      },
+    }
+
+    it 'loads data from global config if present' do
+      expect(Cisco::Environment).to receive(:data_from_file).with(
+        '/etc/cisco_node_utils.yaml').and_return(global_config)
+      env = Cisco::Environment.environments
+      env.each do |key, hash|
+        # The env hash should be fully populated with keys
+        # Any keys unspecified in the data should be nil
+        %I(host port username password).each do |hash_key|
+          expect(hash.fetch(hash_key)).to \
+            eq(global_config[key].fetch(hash_key, nil))
+        end
+      end
+    end
+
+    it 'loads data from user config if present' do
+      expect(Cisco::Environment).to receive(:data_from_file).with(
+        '~/cisco_node_utils.yaml').and_return(user_config)
+      env = Cisco::Environment.environments
+      env.each do |key, hash|
+        # The env hash should be fully populated with keys
+        # Any keys unspecified in the data should be nil
+        %I(host port username password).each do |hash_key|
+          expect(hash.fetch(hash_key)).to \
+            eq(user_config[key].fetch(hash_key, nil))
+        end
+      end
+    end
+
+    it 'uses both files if present but user data takes precedence' do
+      expect(Cisco::Environment).to receive(:data_from_file).with(
+        '/etc/cisco_node_utils.yaml').and_return(global_config)
+      expect(Cisco::Environment).to receive(:data_from_file).with(
+        '~/cisco_node_utils.yaml').and_return(user_config)
+      expect(Cisco::Environment.environments).to eq(
+        'default' => {
+          host:     '127.0.0.1', # global config
+          port:     57_799, # user overrides global
+          username: 'user', # user config
+          password: nil, # auto-populated with nil
+        },
+        'global'  => { # global config
+          host:     nil,
+          port:     nil,
+          username: 'global',
+          password: 'global',
+        },
+        'user'    => { # user config
+          host:     nil,
+          port:     nil,
+          username: 'user',
+          password: 'user',
+        },
+      )
+    end
+  end
+
+  context '.environment' do
+    context 'with no config files available' do
+      before(:each) do
+        allow(Cisco::Environment).to receive(:data_from_file).and_return({})
+      end
+
+      it 'returns DEFAULT_ENVIRONMENT when called with no args' do
+        expect(Cisco::Environment.environment).to \
+          eq(Cisco::Environment::DEFAULT_ENVIRONMENT)
+      end
+      it 'returns DEFAULT_ENVIRONMENT when requested by name as "default"' do
+        expect(Cisco::Environment.environment('default')).to \
+          eq(Cisco::Environment::DEFAULT_ENVIRONMENT)
+      end
+    end
+
+    context 'with examples in docs/cisco_node_utils.yaml.example' do
+      before(:each) do
+        allow(File).to receive(:file?).and_return(true)
+        allow(File).to receive(:readable?).and_return(true)
+        allow(YAML).to receive(:load_file).and_wrap_original do |orig|
+          orig.call(File.expand_path('docs/cisco_node_utils.yaml.example'))
+        end
+      end
+
+      context 'the "nxapi_local" example' do
+        expected = {
+          host:     nil,
+          port:     nil,
+          username: nil,
+          password: nil,
+        }
+        it 'can be loaded explicitly by name' do
+          expect(Cisco::Environment.environment('nxapi_local')).to eq(expected)
+        end
+        it 'can be specified as the default then loaded implicitly' do
+          Cisco::Environment.default_environment_name = 'nxapi_local'
+          expect(Cisco::Environment.environment).to eq(expected)
+        end
+        it 'is valid configuration for the NXAPI client' do
+          hash = Cisco::Environment.environment('nxapi_local')
+          Cisco::Client::NXAPI.validate_args(hash)
+        end
+      end
+
+      context 'the "nxapi_remote" example' do
+        expected = {
+          host:     '192.168.1.100',
+          port:     nil,
+          username: 'devops',
+          password: 'devops',
+        }
+        it 'can be loaded explicitly by name' do
+          expect(Cisco::Environment.environment('nxapi_remote')).to eq(expected)
+        end
+        it 'can be specified as the default then loaded implicitly' do
+          Cisco::Environment.default_environment_name = 'nxapi_remote'
+          expect(Cisco::Environment.environment).to eq(expected)
+        end
+        it 'is valid configuration for the NXAPI client' do
+          hash = Cisco::Environment.environment('nxapi_remote')
+          Cisco::Client::NXAPI.validate_args(hash)
+        end
+      end
+
+      context 'the "grpc_local" example' do
+        expected = {
+          host:     nil,
+          port:     57_999,
+          username: 'admin',
+          password: 'admin',
+        }
+        it 'can be loaded explicitly by name' do
+          expect(Cisco::Environment.environment('grpc_local')).to eq(expected)
+        end
+        it 'can be specified as default then loaded implicitly' do
+          Cisco::Environment.default_environment_name = 'grpc_local'
+          expect(Cisco::Environment.environment).to eq(expected)
+        end
+        it 'is valid configuration for the gRPC client' do
+          hash = Cisco::Environment.environment('grpc_local')
+          Cisco::Client::GRPC.validate_args(hash)
+        end
+      end
+
+      context 'the "grpc_remote" example' do
+        expected = {
+          host:     '192.168.1.100',
+          port:     nil,
+          username: 'admin',
+          password: 'admin',
+        }
+        it 'can be loaded explicitly by name' do
+          expect(Cisco::Environment.environment('grpc_remote')).to eq(expected)
+        end
+        it 'can be specified as default then loaded implicitly' do
+          Cisco::Environment.default_environment_name = 'grpc_remote'
+          expect(Cisco::Environment.environment).to eq(expected)
+        end
+        it 'is valid configuration for the gRPC client' do
+          hash = Cisco::Environment.environment('grpc_remote')
+          Cisco::Client::GRPC.validate_args(hash)
+        end
+      end
+    end
+  end
+end