cisco_node_utils_mgx 2.1.0.1

data/lib/cisco_node_utils/vrf_af.rb

@@ -0,0 +1,327 @@
+# VRF_AF provider class
+#
+# January 2016, Chris Van Heuveln
+#
+# 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 'cisco_cmn_utils'
+require_relative 'node_util'
+require_relative 'feature'
+
+module Cisco
+  # VrfAF - node utility class for VRF Address-Family configuration
+  class VrfAF < NodeUtil
+    def initialize(vrf, af, instantiate=true)
+      validate_args(vrf, af)
+      create if instantiate
+    end
+
+    def to_s
+      "VRF #{@vrf} afi #{@afi} safi #{@safi}"
+    end
+
+    def self.afs
+      hash = {}
+      vrfs = config_get('vrf', 'all_vrfs')
+      vrfs.each do |vrf|
+        hash[vrf] = {}
+        afs = config_get('vrf_af', 'all_afs', vrf: vrf)
+
+        next if afs.nil?
+        afs.each do |af|
+          hash[vrf][af] = VrfAF.new(vrf, af, false)
+        end
+      end
+      hash
+    end
+
+    def create
+      config_set('vrf', 'address_family', set_args_keys(state: ''))
+    end
+
+    def destroy
+      config_set('vrf', 'address_family', set_args_keys(state: 'no'))
+    end
+
+    def validate_args(vrf, af)
+      fail ArgumentError unless vrf.is_a?(String) && (vrf.length > 0)
+      fail ArgumentError, "'af' must be an array specifying afi and safi" unless
+        af.is_a?(Array) || af.length == 2
+      @vrf = vrf.downcase
+      @afi, @safi = af
+      set_args_keys_default
+    end
+
+    def set_args_keys_default
+      keys = { afi: @afi, safi: @safi }
+      keys[:vrf] = @vrf unless @vrf == 'default'
+      @get_args = @set_args = keys
+    end
+
+    def set_args_keys(hash={}) # rubocop:disable Style/AccessorMethodName
+      set_args_keys_default
+      @set_args = @get_args.merge!(hash) unless hash.empty?
+    end
+
+    def route_target_feature_enable(require_nv_overlay=nil, require_ngmvpn=nil)
+      return unless platform == :nexus
+
+      # All NX route-target properties require feature bgp
+      Feature.bgp_enable
+
+      # Some platforms/versions also require nv overlay for some properties
+      if require_nv_overlay
+        Feature.nv_overlay_enable if Feature.nv_overlay_supported?
+        Feature.nv_overlay_evpn_enable if Feature.nv_overlay_evpn_supported?
+      end
+
+      # ngmvpn feature is required for 'mvpn' enablement
+      Feature.ngmvpn_enable if require_ngmvpn
+    end
+
+    ########################################################
+    #                      PROPERTIES                      #
+    ########################################################
+
+    def route_policy_export
+      config_get('vrf_af', 'route_policy_export', @get_args)
+    end
+
+    def route_policy_export=(name)
+      Feature.bgp_enable if platform == :nexus
+      # Nexus requires passing in <policy_name> in "no export map" command.
+      if name
+        set_args_keys(state: '', policy_name: name)
+      else
+        remove_name = config_get('vrf_af', 'route_policy_export', @get_args)
+        return nil if remove_name.nil?
+        set_args_keys(state: 'no', policy_name: remove_name)
+      end
+      config_set('vrf_af', 'route_policy_export', @set_args)
+    end
+
+    def default_route_policy_export
+      config_get_default('vrf_af', 'route_policy_export')
+    end
+
+    def route_policy_import
+      config_get('vrf_af', 'route_policy_import', @get_args)
+    end
+
+    def route_policy_import=(name)
+      Feature.bgp_enable if platform == :nexus
+      # Nexus requires passing in <policy_name> in "no import map" command.
+      if name
+        set_args_keys(state: '', policy_name: name)
+      else
+        remove_name = config_get('vrf_af', 'route_policy_import', @get_args)
+        return nil if remove_name.nil?
+        set_args_keys(state: 'no', policy_name: remove_name)
+      end
+      config_set('vrf_af', 'route_policy_import', @set_args)
+    end
+
+    def default_route_policy_import
+      config_get_default('vrf_af', 'route_policy_import')
+    end
+
+    # --------------------------
+    def route_target_both_auto
+      config_get('vrf_af', 'route_target_both_auto', @get_args)
+    end
+
+    def route_target_both_auto=(state)
+      route_target_feature_enable(:require_nv_overlay)
+      set_args_keys(state: (state ? '' : 'no'))
+      config_set('vrf_af', 'route_target_both_auto', @set_args)
+    end
+
+    def default_route_target_both_auto
+      config_get_default('vrf_af', 'route_target_both_auto')
+    end
+
+    # --------------------------
+    def route_target_both_auto_evpn
+      config_get('vrf_af', 'route_target_both_auto_evpn', @get_args)
+    end
+
+    def route_target_both_auto_evpn=(state)
+      route_target_feature_enable(:require_nv_overlay)
+      set_args_keys(state: (state ? '' : 'no'))
+      config_set('vrf_af', 'route_target_both_auto_evpn', @set_args)
+    end
+
+    def default_route_target_both_auto_evpn
+      config_get_default('vrf_af', 'route_target_both_auto_evpn')
+    end
+
+    # --------------------------
+    def route_target_both_auto_mvpn
+      config_get('vrf_af', 'route_target_both_auto_mvpn', @get_args)
+    end
+
+    def route_target_both_auto_mvpn=(state)
+      route_target_feature_enable(nil, :require_ngmvpn)
+      set_args_keys(state: (state ? '' : 'no'))
+      config_set('vrf_af', 'route_target_both_auto_mvpn', @set_args)
+    end
+
+    def default_route_target_both_auto_mvpn
+      config_get_default('vrf_af', 'route_target_both_auto_mvpn')
+    end
+
+    # --------------------------
+    def route_target_export
+      cmds = config_get('vrf_af', 'route_target_export', @get_args)
+      cmds.nil? ? nil : cmds.sort
+    end
+
+    def route_target_export=(should)
+      route_target_feature_enable
+      route_target_delta(should, route_target_export, 'route_target_export')
+    end
+
+    def default_route_target_export
+      config_get_default('vrf_af', 'route_target_export')
+    end
+
+    # --------------------------
+    def route_target_export_evpn
+      cmds = config_get('vrf_af', 'route_target_export_evpn', @get_args)
+      cmds.nil? ? nil : cmds.sort
+    end
+
+    def route_target_export_evpn=(should)
+      route_target_feature_enable(:require_nv_overlay)
+      route_target_delta(should, route_target_export_evpn,
+                         'route_target_export_evpn')
+    end
+
+    def default_route_target_export_evpn
+      config_get_default('vrf_af', 'route_target_export_evpn')
+    end
+
+    # --------------------------
+    def route_target_export_mvpn
+      cmds = config_get('vrf_af', 'route_target_export_mvpn', @get_args)
+      cmds.nil? ? nil : cmds.sort
+    end
+
+    def route_target_export_mvpn=(should)
+      route_target_feature_enable(nil, :require_ngmvpn)
+      route_target_delta(should, route_target_export_mvpn,
+                         'route_target_export_mvpn')
+    end
+
+    def default_route_target_export_mvpn
+      config_get_default('vrf_af', 'route_target_export_mvpn')
+    end
+
+    # --------------------------
+    def route_target_export_stitching
+      cmds = config_get('vrf_af', 'route_target_export_stitching', @get_args)
+      cmds.nil? ? nil : cmds.sort
+    end
+
+    def route_target_export_stitching=(should)
+      route_target_delta(should, route_target_export_stitching,
+                         'route_target_export_stitching')
+    end
+
+    def default_route_target_export_stitching
+      config_get_default('vrf_af', 'route_target_export_stitching')
+    end
+
+    # --------------------------
+    def route_target_import
+      cmds = config_get('vrf_af', 'route_target_import', @get_args)
+      cmds.nil? ? nil : cmds.sort
+    end
+
+    def route_target_import=(should)
+      route_target_feature_enable
+      route_target_delta(should, route_target_import, 'route_target_import')
+    end
+
+    def default_route_target_import
+      config_get_default('vrf_af', 'route_target_import')
+    end
+
+    # --------------------------
+    def route_target_import_evpn
+      cmds = config_get('vrf_af', 'route_target_import_evpn', @get_args)
+      cmds.nil? ? nil : cmds.sort
+    end
+
+    def route_target_import_evpn=(should)
+      route_target_feature_enable(:require_nv_overlay)
+      route_target_delta(should, route_target_import_evpn,
+                         'route_target_import_evpn')
+    end
+
+    def default_route_target_import_evpn
+      config_get_default('vrf_af', 'route_target_import_evpn')
+    end
+
+    # --------------------------
+    def route_target_import_mvpn
+      cmds = config_get('vrf_af', 'route_target_import_mvpn', @get_args)
+      cmds.nil? ? nil : cmds.sort
+    end
+
+    def route_target_import_mvpn=(should)
+      route_target_feature_enable(nil, :require_ngmvpn)
+      route_target_delta(should, route_target_import_mvpn,
+                         'route_target_import_mvpn')
+    end
+
+    def default_route_target_import_mvpn
+      config_get_default('vrf_af', 'route_target_import_mvpn')
+    end
+
+    # --------------------------
+    def route_target_import_stitching
+      cmds = config_get('vrf_af', 'route_target_import_stitching', @get_args)
+      cmds.nil? ? nil : cmds.sort
+    end
+
+    def route_target_import_stitching=(should)
+      route_target_delta(should, route_target_import_stitching,
+                         'route_target_import_stitching')
+    end
+
+    def default_route_target_import_stitching
+      config_get_default('vrf_af', 'route_target_import_stitching')
+    end
+
+    # --------------------------
+    # route_target_delta is a common helper function for the route_target
+    # properties. It walks the delta hash and adds/removes each target cli.
+    def route_target_delta(should, is, prop)
+      fail Cisco::UnsupportedError.new('vrf_af', prop) if is.nil?
+      delta_hash = Utils.delta_add_remove(should, is)
+      return if delta_hash.values.flatten.empty?
+      [:add, :remove].each do |action|
+        Cisco::Logger.debug("#{prop}" \
+          "#{@get_args}\n #{action}: #{delta_hash[action]}")
+        delta_hash[action].each do |community|
+          state = (action == :add) ? '' : 'no'
+          set_args_keys(state: state, community: community)
+          config_set('vrf_af', prop, @set_args)
+        end
+      end
+    end
+  end # class
+end # module

data/lib/cisco_node_utils/vtp.rb

@@ -0,0 +1,125 @@
+# Mike Wiebe, November 2014
+#
+# 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.
+# 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 'logger'
+
+module Cisco
+  # Vtp - node utility class for VTP configuration management
+  class Vtp < NodeUtil
+    attr_reader :name
+
+    MAX_VTP_DOMAIN_NAME_SIZE = 32
+    MAX_VTP_PASSWORD_SIZE    = 64
+
+    # Constructor for Vtp
+    def initialize(instantiate=true)
+      Feature.vtp_enable if instantiate
+    end
+
+    # Get vtp domain name
+    def self.domain
+      dom_def = config_get_default('vtp', 'domain')
+      if Feature.vtp_enabled?
+        dom = config_get('vtp', 'domain')
+        return dom == '-' ? dom_def : dom
+      else
+        dom_def
+      end
+    end
+
+    # The only way to remove a vtp domain is to turn the vtp
+    # feature off.
+    def destroy
+      Feature.vtp_disable
+    end
+
+    def domain
+      Vtp.domain
+    end
+
+    # Set vtp domain name
+    def domain=(d)
+      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 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
+    def password=(password)
+      fail TypeError if password.nil?
+      fail TypeError unless password.is_a? String
+      fail ArgumentError if password.length > MAX_VTP_PASSWORD_SIZE
+      Feature.vtp_enable
+      state = (password == default_password) ? 'no' : ''
+      config_set('vtp', 'password', state: state, password: password)
+    end
+
+    # Get default vtp password
+    def default_password
+      config_get_default('vtp', 'password')
+    end
+
+    # Get vtp filename
+    def 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?
+      Feature.vtp_enable
+      uri = uri.to_s
+      state = uri.empty? ? 'no' : ''
+      config_set('vtp', 'filename', state: state, uri: uri)
+    end
+
+    # Get default vtp filename
+    def default_filename
+      config_get_default('vtp', 'filename')
+    end
+
+    # Get vtp version
+    def version
+      Feature.vtp_enabled? ? config_get('vtp', 'version') : default_version
+    end
+
+    # Set vtp version
+    def version=(v)
+      Feature.vtp_enable
+      config_set('vtp', 'version', version: v)
+    end
+
+    # Get default vtp version
+    def default_version
+      config_get_default('vtp', 'version')
+    end
+  end
+end