cisco_node_utils 1.1.0 → 1.2.0

data/lib/cisco_node_utils/fabricpath_topology.rb

@@ -0,0 +1,150 @@
+# Fabricpath Topology provider class
+#
+# Deepak Cherian, November 2015
+#
+# 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.
+# 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 'node_util'
+require_relative 'fabricpath_global'
+
+module Cisco
+  # node_utils class for fabricpath_topology
+  class FabricpathTopo < NodeUtil
+    attr_reader :topo_id
+
+    def initialize(topo_id, instantiate=true)
+      @topo_id = topo_id.to_s
+      @set_params = {}
+      fail ArgumentError, "Invalid value(non-numeric
+                          Topo id #{@topo_id})" unless @topo_id[/^\d+$/]
+
+      create if instantiate
+    end
+
+    def self.topos
+      hash = {}
+      fabricpath = config_get('fabricpath', 'feature')
+      return hash if (:enabled != fabricpath.to_sym)
+      topo_list = config_get('fabricpath_topology', 'all_topos')
+      return hash if topo_list.nil?
+
+      topo_list.each do |id|
+        hash[id] = FabricpathTopo.new(id, false)
+      end
+      hash
+    end
+
+    def create
+      fabricpath_feature_set(:enabled) unless :enabled == fabricpath_feature
+      config_set('fabricpath_topology', 'create',
+                 topo: @topo_id) unless @topo_id == '0'
+    end
+
+    def cli_error_check(result)
+      # The NXOS vlan cli does not raise an exception in some conditions and
+      # instead just displays a STDOUT error message; thus NXAPI does not detect
+      # the failure and we must catch it by inspecting the "body" hash entry
+      # returned by NXAPI. This vlan cli behavior is unlikely to change.
+      fail result[2]['body'] unless result[2]['body'].empty?
+    end
+
+    def destroy
+      config_set('fabricpath_topology', 'destroy', topo: @topo_id)
+    end
+
+    def fabricpath_feature
+      FabricpathGlobal.fabricpath_feature
+    end
+
+    def fabricpath_feature_set(fabricpath_set)
+      FabricpathGlobal.fabricpath_feature_set(fabricpath_set)
+    end
+
+    def state
+      result = config_get('fabricpath_topology', 'state', @topo_id)
+      return default_state if result.nil?
+      case result
+      when /Up/
+        return 'up'
+      when /Down/
+        return 'default'
+      end
+    end
+
+    def default_state
+      config_get_default('fabricpath_topology', 'state')
+    end
+
+    def member_vlans
+      str = config_get('fabricpath_topology', 'member_vlans', @topo_id)
+      return [] if str == '--'
+      str.gsub!('-', '..')
+      if /,/.match(str)
+        str.split(/\s*,\s*/)
+      else
+        str.lines.to_a
+      end
+    end
+
+    def member_vlans=(str)
+      debug "str is #{str} whose class is #{str.class}"
+      @set_params = {}
+      str = str.join(',') unless str.empty?
+      if str.empty?
+        @set_params[:topo] = @topo_id
+        @set_params[:state] = 'no'
+        @set_params[:vlan_range] = ''
+      else
+        str.gsub!('..', '-')
+        @set_params[:topo] = @topo_id
+        @set_params[:state] = ''
+        @set_params[:vlan_range] = str
+      end
+      result = config_set('fabricpath_topology', 'member_vlans', @set_params)
+      cli_error_check(result)
+    rescue CliError => e
+      raise "[topo #{@topo_id}] '#{e.command}' : #{e.clierror}"
+    end
+
+    def default_member_vlans
+      []
+    end
+
+    def topo_name
+      config_get('fabricpath_topology', 'description', @topo_id)
+    end
+
+    def topo_name=(desc)
+      fail TypeError unless desc.is_a?(String)
+      @set_params = {}
+      if desc.empty?
+        @set_params[:topo] = @topo_id
+        @set_params[:state] = 'no'
+        @set_params[:name] = ''
+      else
+        @set_params[:topo] = @topo_id
+        @set_params[:state] = ''
+        @set_params[:name] = desc
+      end
+      config_set('fabricpath_topology', 'description', @set_params)
+    rescue Cisco::CliError => e
+      raise "[#{@name}] '#{e.command}' : #{e.clierror}"
+    end
+
+    def default_topo_name
+      config_get_default('fabricpath_topology', 'description')
+    end
+  end # class
+end # module

data/lib/cisco_node_utils/feature.rb

@@ -0,0 +1,111 @@
+# January 2016, Robert W Gries
+#
+# 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.
+# 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 'node_util'
+
+module Cisco
+  # Feature - node util class for managing common features
+  class Feature < NodeUtil
+    # Note that in most cases the enable methods should only enable;
+    # however, for test purposes it is sometimes convenient to support
+    # feature disablement for cleanup purposes.
+    # ---------------------------
+    def self.bgp_enable
+      return if bgp_enabled?
+      config_set('feature', 'bgp')
+    end
+
+    def self.bgp_enabled?
+      config_get('feature', 'bgp')
+    end
+
+    # ---------------------------
+    def self.fabric_enable
+      # install feature-set and enable it
+      return if fabric_enabled?
+      config_set('feature', 'fabric', state: 'install') unless fabric_installed?
+      config_set('feature', 'fabric', state: '')
+    end
+
+    def self.fabric_enabled?
+      config_get('feature', 'fabric') =~ /^enabled/
+    end
+
+    def self.fabric_installed?
+      config_get('feature', 'fabric') !~ /^uninstalled/
+    end
+
+    def self.fabric_supported?
+      config_get('feature', 'fabric')
+    end
+
+    #  ---------------------------
+    def self.fabric_forwarding_enable
+      return if fabric_forwarding_enabled?
+      Feature.fabric_enable if Feature.fabric_supported?
+      # The feature fabric-forwarding cli is required in some older nxos images
+      # but is not present in newer images because nv_overlay_evpn handles
+      # both features; therefore feature fabric-forwarding is best-effort
+      # and ignored on cli failure.
+      begin
+        config_set('feature', 'fabric_forwarding')
+      rescue Cisco::CliError
+        CiscoLogger.debug '"feature fabric forwarding" CLI was rejected'
+      end
+    end
+
+    def self.fabric_forwarding_enabled?
+      config_get('feature', 'fabric_forwarding')
+    end
+
+    # ---------------------------
+    def self.nv_overlay_enable
+      # Note: vdc platforms restrict this feature to F3 or newer linecards
+      return if nv_overlay_enabled?
+      config_set('feature', 'nv_overlay')
+    end
+
+    def self.nv_overlay_enabled?
+      config_get('feature', 'nv_overlay')
+    rescue Cisco::CliError => e
+      # cmd will syntax reject when feature is not enabled.
+      raise unless e.clierror =~ /Syntax error/
+      return false
+    end
+
+    # ---------------------------
+    def self.nv_overlay_evpn_enable
+      return if nv_overlay_evpn_enabled?
+      config_set('feature', 'nv_overlay_evpn')
+    end
+
+    def self.nv_overlay_evpn_enabled?
+      config_get('feature', 'nv_overlay_evpn')
+    end
+
+    # ---------------------------
+    def self.vn_segment_vlan_based_enable
+      return if vn_segment_vlan_based_enabled?
+      config_set('feature', 'vn_segment_vlan_based')
+    end
+
+    def self.vn_segment_vlan_based_enabled?
+      config_get('feature', 'vn_segment_vlan_based')
+    end
+
+    # ---------------------------
+  end
+end

data/lib/cisco_node_utils/interface.rb

@@ -1,6 +1,6 @@
 # November 2015, Chris Van Heuveln
 #
-# 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.
@@ -14,7 +14,12 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
+require_relative 'cisco_cmn_utils'
 require_relative 'node_util'
+require_relative 'pim'
+require_relative 'vrf'
+require_relative 'vni'
+require_relative 'overlay_global'
 
 # Add some interface-specific constants to the Cisco namespace
 module Cisco
@@ -24,6 +29,7 @@ module Cisco
     trunk:      'trunk',
     fex_fabric: 'fex-fabric',
     tunnel:     'dot1q-tunnel',
+    fabricpath: 'fabricpath',
   }
 
   # Interface - node utility class for general interface config management
@@ -64,9 +70,7 @@ module Cisco
     ########################################################
 
     def access_vlan
-      vlan = config_get('interface', 'access_vlan', @name)
-      return default_access_vlan if vlan.nil?
-      vlan.shift.to_i
+      config_get('interface', 'access_vlan', @name)
     end
 
     def access_vlan=(vlan)
@@ -75,14 +79,90 @@ module Cisco
       raise "[#{@name}] '#{e.command}' : #{e.clierror}"
     end
 
+    def ipv4_acl_in
+      config_get('interface', 'ipv4_acl_in', @name)
+    end
+
+    def ipv4_acl_in=(val)
+      if val != ''
+        state = ''
+      else
+        state = 'no'
+        val = ipv4_acl_in
+      end
+
+      return unless val && val != ''
+      config_set('interface', 'ipv4_acl_in', @name, state, val)
+    end
+
+    def default_ipv4_acl_in
+      config_get_default('interface', 'ipv4_acl_in')
+    end
+
+    def ipv4_acl_out
+      config_get('interface', 'ipv4_acl_out', @name)
+    end
+
+    def ipv4_acl_out=(val)
+      if val != ''
+        state = ''
+      else
+        state = 'no'
+        val = ipv4_acl_out
+      end
+
+      return unless val && val != ''
+      config_set('interface', 'ipv4_acl_out', @name, state, val)
+    end
+
+    def default_ipv4_acl_out
+      config_get_default('interface', 'ipv4_acl_out')
+    end
+
+    def ipv6_acl_in
+      config_get('interface', 'ipv6_acl_in', @name)
+    end
+
+    def ipv6_acl_in=(val)
+      if val != ''
+        state = ''
+      else
+        state = 'no'
+        val = ipv6_acl_in
+      end
+      return unless val && val != ''
+      config_set('interface', 'ipv6_acl_in', @name, state, val)
+    end
+
+    def default_ipv6_acl_in
+      config_get_default('interface', 'ipv6_acl_in')
+    end
+
+    def ipv6_acl_out
+      config_get('interface', 'ipv6_acl_out', @name)
+    end
+
+    def ipv6_acl_out=(val)
+      if val != ''
+        state = ''
+      else
+        state = 'no'
+        val = ipv6_acl_out
+      end
+      return unless val && val != ''
+      config_set('interface', 'ipv6_acl_out', @name, state, val)
+    end
+
+    def default_ipv6_acl_out
+      config_get_default('interface', 'ipv6_acl_out')
+    end
+
     def default_access_vlan
       config_get_default('interface', 'access_vlan')
     end
 
     def description
-      desc = config_get('interface', 'description', @name)
-      return '' if desc.nil?
-      desc.shift.strip
+      config_get('interface', 'description', @name)
     end
 
     def description=(desc)
@@ -101,9 +181,7 @@ module Cisco
     end
 
     def encapsulation_dot1q
-      val = config_get('interface', 'encapsulation_dot1q', @name)
-      return default_encapsulation_dot1q if val.nil?
-      val.shift.strip.to_i
+      config_get('interface', 'encapsulation_dot1q', @name)
     end
 
     def encapsulation_dot1q=(val)
@@ -120,10 +198,43 @@ module Cisco
       config_get_default('interface', 'encapsulation_dot1q')
     end
 
+    def fabricpath_feature
+      FabricpathGlobal.fabricpath_feature
+    end
+
+    def fabricpath_feature_set(fabricpath_set)
+      FabricpathGlobal.fabricpath_feature_set(fabricpath_set)
+    end
+
+    def fabric_forwarding_anycast_gateway
+      config_get('interface', 'fabric_forwarding_anycast_gateway', @name)
+    end
+
+    def fabric_forwarding_anycast_gateway=(state)
+      no_cmd = (state ? '' : 'no')
+      config_set('interface',
+                 'fabric_forwarding_anycast_gateway', @name, no_cmd)
+      fail if fabric_forwarding_anycast_gateway.to_s != state.to_s
+    rescue Cisco::CliError => e
+      info = "[#{@name}] '#{e.command}' : #{e.clierror}"
+      raise "#{info} 'fabric_forwarding_anycast_gateway' can only be " \
+        'configured on a vlan interface' unless /vlan/.match(@name)
+      anycast_gateway_mac = OverlayGlobal.new.anycast_gateway_mac
+      if anycast_gateway_mac.nil? || anycast_gateway_mac.empty?
+        raise "#{info} Anycast gateway mac must be configured " \
+               'before configuring forwarding mode under interface'
+      end
+      raise info
+    end
+
+    def default_fabric_forwarding_anycast_gateway
+      config_get_default('interface', 'fabric_forwarding_anycast_gateway')
+    end
+
     def fex_feature
       fex = config_get('fex', 'feature')
       fail 'fex_feature not found' if fex.nil?
-      fex.shift.to_sym
+      fex.to_sym
     end
 
     def fex_feature_set(fex_set)
@@ -147,47 +258,127 @@ module Cisco
       raise "[#{@name}] '#{e.command}' : #{e.clierror}"
     end
 
-    def ipv4_addr_mask
-      config_get('interface', 'ipv4_addr_mask', @name)
-    end
-
-    def ipv4_addr_mask_set(addr, mask)
+    def ipv4_addr_mask_set(addr, mask, secondary=false)
       check_switchport_disabled
+      sec = secondary ? 'secondary' : ''
       if addr.nil? || addr == default_ipv4_address
-        config_set('interface', 'ipv4_addr_mask', @name, 'no', '')
+        state = 'no'
+        if secondary
+          return if ipv4_address_secondary == default_ipv4_address_secondary
+          # We need address and mask to remove.
+          am = "#{ipv4_address_secondary}/#{ipv4_netmask_length_secondary}"
+        else
+          return if ipv4_address == default_ipv4_address
+          am = "#{ipv4_address}/#{ipv4_netmask_length}"
+        end
       else
-        config_set('interface', 'ipv4_addr_mask', @name, '',
-                   "#{addr}/#{mask}")
+        state = ''
+        am = "#{addr}/#{mask}"
       end
+      config_set('interface', 'ipv4_addr_mask', @name, state, am, sec)
     rescue Cisco::CliError => e
       raise "[#{@name}] '#{e.command}' : #{e.clierror}"
     end
 
+    def ipv4_addr_mask
+      config_get('interface', 'ipv4_addr_mask', @name)
+    end
+
+    def select_ipv4_attribute(attribute)
+      d = ipv4_addr_mask.flatten unless ipv4_addr_mask.nil?
+      # (d)ata format after flatten: ['addr', 'mask', 'addr', 'mask secondary']
+      case attribute
+      when :v4_addr
+        v = d.nil? ? default_ipv4_address : d[0]
+      when :v4_mask
+        v = d.nil? ? default_ipv4_netmask_length : d[1].to_i
+      when :v4_addr_secondary
+        v = (d.nil? || d.size < 4) ? default_ipv4_address : d[2]
+      when :v4_mask_secondary
+        if d.nil? || d.size < 4
+          v = default_ipv4_netmask_length
+        else
+          v = d[3][0, 2].to_i
+        end
+      end
+      v
+    end
+
     def ipv4_address
-      val = ipv4_addr_mask
-      return default_ipv4_address if val.nil?
-      # val is [[addr, mask]] - we just want the addr
-      val.shift.first
+      select_ipv4_attribute(:v4_addr)
+    end
+
+    def ipv4_address_secondary
+      select_ipv4_attribute(:v4_addr_secondary)
+    end
+
+    def ipv4_netmask_length
+      select_ipv4_attribute(:v4_mask)
+    end
+
+    def ipv4_netmask_length_secondary
+      select_ipv4_attribute(:v4_mask_secondary)
     end
 
     def default_ipv4_address
       config_get_default('interface', 'ipv4_address')
     end
 
-    def ipv4_netmask_length
-      val = ipv4_addr_mask
-      return default_ipv4_netmask_length if val.nil?
-      # val is [[addr, mask]] - we just want the mask
-      val.shift.last.to_i
+    def default_ipv4_address_secondary
+      default_ipv4_address
     end
 
     def default_ipv4_netmask_length
       config_get_default('interface', 'ipv4_netmask_length')
     end
 
+    def default_ipv4_netmask_length_secondary
+      default_ipv4_netmask_length
+    end
+
+    def ipv4_arp_timeout_lookup_string
+      case @name
+      when /vlan/i
+        return 'ipv4_arp_timeout'
+      else
+        return 'ipv4_arp_timeout_non_vlan_interfaces'
+      end
+    end
+
+    def ipv4_arp_timeout
+      config_get('interface', ipv4_arp_timeout_lookup_string, @name)
+    end
+
+    def ipv4_arp_timeout=(timeout)
+      fail "'ipv4 arp timeout' can ony be configured on a vlan interface" unless
+        /vlan/.match(@name)
+      state = (timeout == default_ipv4_arp_timeout) ? 'no' : ''
+      config_set('interface', 'ipv4_arp_timeout', @name, state, timeout)
+    end
+
+    def default_ipv4_arp_timeout
+      config_get_default('interface', ipv4_arp_timeout_lookup_string)
+    end
+
+    def ipv4_pim_sparse_mode
+      config_get('interface', 'ipv4_pim_sparse_mode', @name)
+    end
+
+    def ipv4_pim_sparse_mode=(state)
+      check_switchport_disabled
+      Pim.feature_enable unless Pim.feature_enabled
+      config_set('interface', 'ipv4_pim_sparse_mode', @name,
+                 state ? '' : 'no')
+    rescue Cisco::CliError => e
+      raise "[#{@name}] '#{e.command}' : #{e.clierror}"
+    end
+
+    def default_ipv4_pim_sparse_mode
+      config_get_default('interface', 'ipv4_pim_sparse_mode')
+    end
+
     def ipv4_proxy_arp
-      state = config_get('interface', 'ipv4_proxy_arp', @name)
-      state.nil? ? false : true
+      config_get('interface', 'ipv4_proxy_arp', @name)
     end
 
     def ipv4_proxy_arp=(proxy_arp)
@@ -210,24 +401,13 @@ module Cisco
     end
 
     def ipv4_redirects
-      begin
-        state = config_get('interface',
-                           ipv4_redirects_lookup_string, @name)
-      rescue IndexError
-        state = nil
-      end
-      # We return default state for the platform if the platform doesn't support
-      # the command
-      return default_ipv4_redirects if state.nil? || state.empty?
-      state.shift[/^ip redirects$/] ? true : false
+      config_get('interface', ipv4_redirects_lookup_string, @name)
     end
 
     def ipv4_redirects=(redirects)
       check_switchport_disabled
       no_cmd = (redirects ? '' : 'no')
       config_set('interface', ipv4_redirects_lookup_string, @name, no_cmd)
-    rescue IndexError
-      raise "ipv4 redirects not supported on #{@name}"
     end
 
     def default_ipv4_redirects
@@ -235,7 +415,7 @@ module Cisco
     end
 
     def feature_lacp?
-      !config_get('interface', 'feature_lacp').nil?
+      config_get('interface', 'feature_lacp')
     end
 
     def feature_lacp_set(val)
@@ -244,9 +424,7 @@ module Cisco
     end
 
     def mtu
-      mtu = config_get('interface', 'mtu', @name)
-      return default_mtu if mtu.nil?
-      mtu.shift.strip.to_i
+      config_get('interface', 'mtu', @name)
     end
 
     def mtu=(val)
@@ -260,6 +438,40 @@ module Cisco
       config_get_default('interface', 'mtu')
     end
 
+    def speed
+      config_get('interface', 'speed', @name)
+    end
+
+    def speed=(val)
+      if node.product_id =~ /C31\d\d/
+        fail 'Changing interface speed is not permitted on this platform'
+      end
+      config_set('interface', 'speed', @name, val)
+    rescue Cisco::CliError => e
+      raise "[#{@name}] '#{e.command}' : #{e.clierror}"
+    end
+
+    def default_speed
+      config_get_default('interface', 'speed')
+    end
+
+    def duplex
+      config_get('interface', 'duplex', @name)
+    end
+
+    def duplex=(val)
+      if node.product_id =~ /C31\d\d/
+        fail 'Changing interface duplex is not permitted on this platform'
+      end
+      config_set('interface', 'duplex', @name, val)
+    rescue Cisco::CliError => e
+      raise "[#{@name}] '#{e.command}' : #{e.clierror}"
+    end
+
+    def default_duplex
+      config_get_default('interface', 'duplex')
+    end
+
     def negotiate_auto_lookup_string
       case @name
       when /Ethernet/i
@@ -272,29 +484,13 @@ module Cisco
     end
 
     def negotiate_auto
-      lookup = negotiate_auto_lookup_string
-      begin
-        state = config_get('interface', lookup, @name)
-      rescue IndexError
-        # We return default state even if the config_get is not supported
-        # for this platform / interface type. This is done so that we can set
-        # the manifest to 'default' so there is a 'workaround' for the
-        # unsupported attribute
-        return default_negotiate_auto
-      end
-      state.nil? ? false : true
+      config_get('interface', negotiate_auto_lookup_string, @name)
     end
 
     def negotiate_auto=(negotiate_auto)
       lookup = negotiate_auto_lookup_string
       no_cmd = (negotiate_auto ? '' : 'no')
-      begin
-        config_set('interface', lookup, @name, no_cmd)
-      rescue Cisco::CliError => e
-        raise "[#{@name}] '#{e.command}' : #{e.clierror}"
-      rescue IndexError
-        raise "[#{@name}] negotiate_auto is not supported on this interface"
-      end
+      config_set('interface', lookup, @name, no_cmd)
     end
 
     def default_negotiate_auto
@@ -302,8 +498,7 @@ module Cisco
     end
 
     def shutdown
-      state = config_get('interface', 'shutdown', @name)
-      state ? true : false
+      config_get('interface', 'shutdown', @name)
     end
 
     def shutdown=(state)
@@ -348,8 +543,7 @@ module Cisco
 
     def switchport
       # This is "switchport", not "switchport mode"
-      sw = config_get('interface', 'switchport', @name)
-      sw.nil? ? false : true
+      config_get('interface', 'switchport', @name)
     end
 
     def switchport_enable(val=true)
@@ -358,8 +552,8 @@ module Cisco
 
     # switchport_autostate_exclude is exclusive to switchport interfaces
     def switchport_autostate_exclude
-      !config_get('interface',
-                  'switchport_autostate_exclude', @name).nil?
+      config_get('interface',
+                 'switchport_autostate_exclude', @name)
     end
 
     def switchport_autostate_exclude=(val)
@@ -389,7 +583,7 @@ module Cisco
     def switchport_mode
       mode = config_get('interface', switchport_mode_lookup_string, @name)
 
-      return mode.nil? ? :disabled : IF_SWITCHPORT_MODE.key(mode.shift)
+      return mode.nil? ? :disabled : IF_SWITCHPORT_MODE.key(mode)
 
     rescue IndexError
       # Assume this is an interface that doesn't support switchport.
@@ -401,8 +595,10 @@ module Cisco
     def switchport_enable_and_mode(mode_set)
       switchport_enable unless switchport
 
-      if (:fex_fabric == mode_set)
-        fex_feature_set(:enabled) unless (:enabled == fex_feature)
+      if :fabricpath == mode_set
+        fabricpath_feature_set(:enabled) unless :enabled == fabricpath_feature
+      elsif :fex_fabric == mode_set
+        fex_feature_set(:enabled) unless :enabled == fex_feature
       end
       config_set('interface', switchport_mode_lookup_string, @name, '',
                  IF_SWITCHPORT_MODE[mode_set])
@@ -447,10 +643,7 @@ module Cisco
     end
 
     def switchport_trunk_allowed_vlan
-      val = config_get(
-        'interface', 'switchport_trunk_allowed_vlan', @name)
-      return default_switchport_trunk_allowed_vlan if val.nil?
-      val.shift.strip
+      config_get('interface', 'switchport_trunk_allowed_vlan', @name)
     end
 
     def switchport_trunk_allowed_vlan=(val)
@@ -470,10 +663,7 @@ module Cisco
     end
 
     def switchport_trunk_native_vlan
-      val = config_get(
-        'interface', 'switchport_trunk_native_vlan', @name)
-      return default_switchport_trunk_native_vlan if val.nil?
-      val.shift.strip.to_i
+      config_get('interface', 'switchport_trunk_native_vlan', @name)
     end
 
     def switchport_trunk_native_vlan=(val)
@@ -488,28 +678,103 @@ module Cisco
       raise "[#{@name}] '#{e.command}' : #{e.clierror}"
     end
 
+    # vlan_mapping & vlan_mapping_enable
+    #  Hardware & Cli Dependencies:
+    #   - F3 linecards only
+    #   - vdc
+    #   - limit-resource
+    #   - bridge-domain
+    #   - feature vni
+    #   - switchport mode
+
+    # Getter: Builds an array of vlan_mapping commands currently
+    # on the device.
+    #   cli: switchport vlan mapping 2 200
+    #        switchport vlan mapping 4 400
+    # array: [['2', '200'], ['4', '400']]
+    #
+    def default_vlan_mapping
+      config_get_default('interface', 'vlan_mapping')
+    end
+
+    def vlan_mapping
+      match = config_get('interface', 'vlan_mapping', @name)
+      match.each(&:compact!) unless match.nil?
+      match
+    end
+
+    def vlan_mapping=(should_list)
+      Vni.feature_vni_enable unless Vni.feature_vni_enabled
+
+      # Process a hash of vlan_mapping cmds from delta_add_remove().
+      # The vlan_mapping cli does not allow commands to be updated, they must
+      # first be removed if there is a change.
+      delta_hash = Utils.delta_add_remove(should_list, vlan_mapping,
+                                          :updates_not_allowed)
+      return if delta_hash.values.flatten.empty?
+      # Process :remove first to ensure "update" commands will not fail.
+      [:remove, :add].each do |action|
+        CiscoLogger.debug("vlan_mapping delta #{@get_args}\n"\
+                          "#{action}: #{delta_hash[action]}")
+        delta_hash[action].each do |original, translated|
+          state = (action == :add) ? '' : 'no'
+          config_set('interface', 'vlan_mapping', @name,
+                     state, original, translated)
+        end
+      end
+    rescue Cisco::CliError => e
+      raise "[#{@name}] '#{e.command}' : #{e.clierror}"
+    end
+
+    # cli: switchport vlan mapping enable
+    def default_vlan_mapping_enable
+      config_get_default('interface', 'vlan_mapping_enable')
+    end
+
+    def vlan_mapping_enable
+      config_get('interface', 'vlan_mapping_enable', @name)
+    end
+
+    def vlan_mapping_enable=(state)
+      config_set('interface', 'vlan_mapping_enable', @name,
+                 state ? '' : 'no')
+    end
+
     def default_switchport_trunk_native_vlan
       config_get_default('interface', 'switchport_trunk_native_vlan')
     end
 
     def system_default_switchport
       # This command is a user-configurable system default.
-      sys_def = config_get('interface', 'system_default_switchport')
-      sys_def.nil? ? false : true
+      #
+      # Note: This is a simple boolean state but there is a bug on some
+      # platforms that causes the cli to nvgen twice; this causes config_get to
+      # raise an error when it encounters the multiple. Therefore we define it
+      # as a multiple to avoid the raise and handle the array if necessary.
+      #
+      val = config_get('interface', 'system_default_switchport')
+      return (val[0][/^no /] ? false : true) if val.is_a?(Array)
+      val
     end
 
     def system_default_switchport_shutdown
       # This command is a user-configurable system default.
-      sys_def = config_get('interface',
-                           'system_default_switchport_shutdown')
-      sys_def.nil? ? false : true
+      config_get('interface', 'system_default_switchport_shutdown')
     end
 
     def system_default_svi_autostate
       # This command is a user-configurable system default.
-      sys_def = config_get('interface',
-                           'system_default_svi_autostate')
-      sys_def.nil? ? false : true
+      #
+      # This property behaves differently on an n7k vs ni(3|9)k and therefore
+      # needs special handling.
+      # N7K: When enabled, does not nvgen.
+      #      When disabled, does nvgen, but differently then n(3|9)k.
+      #      Return true for the disabled case, false otherwise.
+      # N(3|9)K: When enabled, does nvgen.
+      #          When disabled, does nvgen.
+      #          Return true for the enabled case, false otherwise.
+      result = config_get('interface', 'system_default_svi_autostate')
+      /N7K/.match(node.product_id) ? !result : result
     end
 
     def switchport_vtp_mode_capable?
@@ -518,8 +783,7 @@ module Cisco
 
     def switchport_vtp
       return false unless switchport_vtp_mode_capable?
-      vtp = config_get('interface', 'vtp', @name)
-      vtp.nil? ? false : true
+      config_get('interface', 'vtp', @name)
     end
 
     def switchport_vtp=(vtp_set)
@@ -538,7 +802,7 @@ module Cisco
     # svi_autostate is exclusive to svi interfaces
     def svi_autostate
       return nil unless @name[/^vlan/i]
-      !config_get('interface', 'svi_autostate', @name).nil?
+      config_get('interface', 'svi_autostate', @name)
     end
 
     def svi_autostate=(val)
@@ -552,7 +816,7 @@ module Cisco
     end
 
     def feature_vlan?
-      !config_get('interface', 'feature_vlan').nil?
+      config_get('interface', 'feature_vlan')
     end
 
     def feature_vlan_set(val)
@@ -563,7 +827,7 @@ module Cisco
     # svi_management is exclusive to svi interfaces
     def svi_management
       return nil unless @name[/^vlan/i]
-      !config_get('interface', 'svi_management', @name).nil?
+      config_get('interface', 'svi_management', @name)
     end
 
     def svi_management=(val)
@@ -589,10 +853,39 @@ module Cisco
         ' is disabled' unless switchport_mode == :disabled
     end
 
+    def vpc_id
+      config_get('interface', 'vpc_id', @name)
+    end
+
+    def vpc_id=(num)
+      if num
+        config_set('interface', 'vpc_id', @name, '', num)
+      else
+        # 'no vpc' doesn't work for phy ports, so do a get
+        num = vpc_id
+        config_set('interface', 'vpc_id', @name, 'no', num)
+      end
+    end
+
+    def default_vpc_id
+      config_get_default('interface', 'vpc_id')
+    end
+
+    def vpc_peer_link
+      config_get('interface', 'vpc_peer_link', @name)
+    end
+
+    def vpc_peer_link=(state)
+      no_cmd = (state ? '' : 'no')
+      config_set('interface', 'vpc_peer_link', @name, no_cmd)
+    end
+
+    def default_vpc_peer_link
+      config_get_default('interface', 'vpc_peer_link')
+    end
+
     def vrf
-      vrf = config_get('interface', 'vrf', @name)
-      return '' if vrf.nil?
-      vrf.shift.strip
+      config_get('interface', 'vrf', @name)
     end
 
     def vrf=(vrf)