cisco_node_utils_mgx 2.1.0.1

data/lib/cisco_node_utils/evpn_vni.rb

@@ -0,0 +1,159 @@
+# December 2015, Andi Shen
+#
+# 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
+  # node_utils class for evpn_vni
+  class EvpnVni < NodeUtil
+    attr_reader :vni
+
+    def initialize(vni, instantiate=true)
+      err_msg = "vni must be either a 'String' or an" \
+                " 'Integer' object"
+      fail ArgumentError, err_msg unless vni.is_a?(Integer) ||
+                                         vni.is_a?(String)
+      @vni = vni.to_i
+      @get_args = @set_args = { vni: @vni }
+      create if instantiate
+    end
+
+    # Creat a hash of all vni instance
+    def self.vnis
+      hash = {}
+      return hash unless Feature.bgp_enabled?
+      vni_list = config_get('evpn_vni', 'vni')
+      return hash if vni_list.nil?
+
+      vni_list.each do |vni_id|
+        hash[vni_id] = EvpnVni.new(vni_id, false)
+      end
+      hash
+    end
+
+    def create
+      EvpnVni.enable unless EvpnVni.enabled
+      @set_args[:state] = ''
+      config_set('evpn_vni', 'vni', @set_args)
+    end
+
+    def destroy
+      @set_args[:state] = 'no'
+      config_set('evpn_vni', 'vni', @set_args)
+
+      # no evpn if no vni left
+      vni_list = config_get('evpn_vni', 'vni')
+      config_set('evpn_vni', 'evpn', @set_args) if vni_list.nil?
+    end
+
+    # enable feature bgp and nv overlay evpn
+    def self.enable
+      Feature.bgp_enable
+      Feature.nv_overlay_evpn_enable
+    end
+
+    def self.enabled
+      Feature.bgp_enabled? && Feature.nv_overlay_evpn_enabled?
+    end
+
+    def set_args_keys_default
+      @set_args = { vni: @vni }
+    end
+
+    # Attributes:
+    # Route Distinguisher (Getter/Setter/Default)
+    def route_distinguisher
+      config_get('evpn_vni', 'route_distinguisher', @get_args)
+    end
+
+    def route_distinguisher=(rd)
+      if rd == default_route_distinguisher
+        @set_args[:state] = 'no'
+        # I2 images require an rd for removal
+        rd = route_distinguisher
+        return if rd.to_s.empty?
+      else
+        @set_args[:state] = ''
+      end
+      @set_args[:rd] = rd
+      config_set('evpn_vni', 'route_distinguisher', @set_args)
+      set_args_keys_default
+    end
+
+    def default_route_distinguisher
+      config_get_default('evpn_vni', 'route_distinguisher')
+    end
+
+    # route target both
+    def route_target_both
+      cmds = config_get('evpn_vni', 'route_target_both', @get_args)
+      cmds.sort
+    end
+
+    def route_target_both=(should)
+      route_target_delta(should, route_target_both, 'route_target_both')
+    end
+
+    def default_route_target_both
+      config_get_default('evpn_vni', 'route_target_both')
+    end
+
+    # route target export
+    def route_target_export
+      cmds = config_get('evpn_vni', 'route_target_export', @get_args)
+      cmds.sort
+    end
+
+    def route_target_export=(should)
+      route_target_delta(should, route_target_export, 'route_target_export')
+    end
+
+    def default_route_target_export
+      config_get_default('evpn_vni', 'route_target_export')
+    end
+
+    # route target import
+    def route_target_import
+      cmds = config_get('evpn_vni', 'route_target_import', @get_args)
+      cmds.sort
+    end
+
+    def route_target_import=(should)
+      route_target_delta(should, route_target_import, 'route_target_import')
+    end
+
+    def default_route_target_import
+      config_get_default('evpn_vni', 'route_target_import')
+    end
+
+    def route_target_delta(should, is, prop)
+      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[:state] = state
+          @set_args[:community] = community
+          config_set('evpn_vni', prop, @set_args)
+        end
+      end
+    end
+  end
+end

data/lib/cisco_node_utils/exceptions.rb

@@ -0,0 +1,140 @@
+# March 2016, Glenn F. Matthews
+#
+# 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.
+
+# Add generic exception classes to the Cisco module
+# The hierarchy is:
+# RuntimeError
+#   Cisco::CiscoError
+#     Cisco::ClientError
+#       Cisco::ConnectionRefused
+#       Cisco::AuthenticationFailed
+#     Cisco::RequestFailed
+#       Cisco::CliError
+#       Cisco::RequestNotSupported
+#     Cisco::UnsupportedError
+module Cisco
+  # Generic class for exceptions raised by this module
+  class CiscoError < RuntimeError
+    attr_reader :kwargs
+
+    def initialize(message=nil, **kwargs)
+      @kwargs = kwargs
+      super(message)
+    end
+
+    def respond_to?(method_sym, include_private=false)
+      @kwargs.key?(method_sym) ? true : super
+    end
+
+    def method_missing(method_sym, *args, **kwargs, &block)
+      @kwargs.key?(method_sym) ? @kwargs[method_sym] : super
+    end
+  end
+
+  # Exception class for fundamental client failures
+  class ClientError < CiscoError
+  end
+
+  # ConnectionRefused means the server isn't listening
+  class ConnectionRefused < ClientError
+  end
+
+  # AuthenticationFailed means we were able to connect but not login
+  class AuthenticationFailed < ClientError
+  end
+
+  # Exception class for failures of a specific request to the client
+  class RequestFailed < CiscoError
+  end
+
+  # Extension of RequestFailed class specifically for CLI errors
+  class CliError < RequestFailed
+    def initialize(message=nil,
+                   clierror:         nil,
+                   rejected_input:   nil,
+                   successful_input: [],
+                   **kwargs)
+      unless message
+        if rejected_input.is_a?(Array)
+          if rejected_input.length > 1
+            message = "The following commands were rejected:\n"
+            message += "  #{rejected_input.join("\n  ")}\n"
+          else
+            message = "The command '#{rejected_input.first}' was rejected "
+          end
+        else
+          message = "The command '#{rejected_input}' was rejected "
+        end
+        message += "with error:\n#{clierror}"
+      end
+      super(message,
+            :clierror => clierror,
+            :rejected_input => rejected_input,
+            :successful_input => successful_input,
+            **kwargs)
+    end
+  end
+
+  # Extension of RequestFailed class specifically for YANG errors
+  class YangError < RequestFailed
+    def initialize(message=nil,
+                   error: nil,
+                   rejected_input:   nil,
+                   successful_input: [],
+                   **kwargs)
+      unless message
+        if rejected_input.is_a?(Array)
+          if rejected_input.length > 1
+            message = "The following configs were rejected:\n"
+            message += "  #{rejected_input.join("\n  ")}\n"
+          else
+            message = "The config '#{rejected_input.first}' was rejected "
+          end
+        else
+          message = "The config '#{rejected_input}' was rejected "
+        end
+
+        message += "with error:\n#{error}"
+      end
+      super(message,
+            :error => error,
+            :rejected_input => rejected_input,
+            :successful_input => successful_input,
+            **kwargs)
+    end
+  end
+
+  # RequestNotSupported means we made a request that was validly
+  # constructed but includes options that are unsupported.
+  #
+  # An example would be requesting structured output on a CLI command
+  # that only supports ASCII output.
+  class RequestNotSupported < RequestFailed
+  end
+
+  # Exception class raised by CommandReference to indicate that
+  # a particular feature/attribute is explicitly excluded on the given node.
+  class UnsupportedError < CiscoError
+    def initialize(feature, name, oper=nil, msg=nil)
+      message = "Feature '#{feature}'"
+      message += ", attribute '#{name}'" unless name.nil?
+      message += ", operation '#{oper}'" unless oper.nil?
+      message += ' is unsupported on this node'
+      message += ": #{msg}" unless msg.nil?
+      super(message, feature: feature, name: name, oper: oper)
+    end
+  end
+end

data/lib/cisco_node_utils/fabricpath_global.rb

@@ -0,0 +1,405 @@
+#
+# NXAPI implementation of Fabricpath Global class
+#
+# November 2015, Deepak Cherian
+#
+# 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 'vdc'
+
+module Cisco
+  # node_utils class for fabricpath_global
+  class FabricpathGlobal < NodeUtil
+    attr_reader :name
+
+    def initialize(name, instantiate=true)
+      fail ArgumentError unless name.to_s == 'default'
+      @name = name.downcase
+
+      create if instantiate
+    end
+
+    def self.globals
+      hash = {}
+      feature = config_get('fabricpath', 'feature')
+      return hash if feature.nil? || feature.to_sym != :enabled
+      hash['default'] = FabricpathGlobal.new('default', false)
+      hash
+    rescue Cisco::CliError => e
+      # cmd will syntax reject when feature is not enabled
+      raise unless e.clierror =~ /Syntax error/
+      return {}
+    end
+
+    def self.fabricpath_feature
+      fabricpath = config_get('fabricpath', 'feature')
+      return :disabled if fabricpath.nil?
+      fabricpath.to_sym
+    rescue Cisco::CliError => e
+      # cmd will syntax reject when feature is not enabled
+      raise unless e.clierror =~ /Syntax error/
+      return :disabled
+    end
+
+    def self.fabricpath_enable
+      # TBD: Move to Feature provider
+      FabricpathGlobal.fabricpath_feature_set(:enabled) unless
+        FabricpathGlobal.fabricpath_feature == :enabled
+    end
+
+    def self.fabricpath_feature_set(fabricpath_set)
+      curr = FabricpathGlobal.fabricpath_feature
+      return if curr == fabricpath_set
+
+      # NOTE: Add this in future if we want to automatically move only supported
+      # interfaces into the VDC
+      # if Vdc.vdc_support
+      #   # For modular platforms, make sure to limit the feature to
+      #   # modules which support this feature
+      #   if fabricpath_set == :installed || fabricpath_set == :enabled
+      #     v = Vdc.new('default')
+      #     v.limit_resource_module_type =
+      #        config_get('fabricpath', 'supported_modules')
+      #     # exception will be raised for un-supported platforms/modules
+      #   end
+      # end
+
+      case fabricpath_set
+      when :enabled
+        config_set('fabricpath', 'feature_install',
+                   state: '') if curr == :uninstalled
+        config_set('fabricpath', 'feature', state: '')
+      when :disabled
+        config_set('fabricpath', 'feature', state: 'no') if curr == :enabled
+        return
+      when :installed
+        config_set('fabricpath', 'feature_install',
+                   state: '') if curr == :uninstalled
+      when :uninstalled
+        config_set('fabricpath', 'feature', state: 'no') if curr == :enabled
+        config_set('fabricpath', 'feature_install', state: 'no')
+      end
+    end
+
+    def create
+      FabricpathGlobal.fabricpath_enable
+    end
+
+    def destroy
+      @name = nil
+      FabricpathGlobal.fabricpath_feature_set(:disabled)
+    end
+
+    def loadbalance_munge(property, set_val)
+      case property
+      when /loadbalance_algorithm/
+        val = config_get_default('fabricpath', property)
+        return val if (val == 'source-destination') && set_val[/symmetric|xor/]
+        set_val
+      when /loadbalance_.*_rotate/
+        return '' if set_val == ''
+        "rotate-amount 0x#{set_val.to_i.to_s(16)}"
+      else
+        set_val
+      end
+    end
+
+    ########################################################
+    #                      PROPERTIES                      #
+    ########################################################
+
+    def aggregate_multicast_routes
+      config_get('fabricpath', 'aggregate_multicast_routes')
+    end
+
+    def aggregate_multicast_routes=(val)
+      state = val ? '' : 'no'
+      config_set('fabricpath', 'aggregate_multicast_routes', state: state)
+    end
+
+    def default_aggregate_multicast_routes
+      config_get_default('fabricpath', 'aggregate_multicast_routes')
+    end
+
+    def allocate_delay
+      config_get('fabricpath', 'allocate_delay')
+    end
+
+    def allocate_delay=(val)
+      state = val ? '' : 'no'
+      delay = val ? val : ''
+      config_set('fabricpath', 'allocate_delay', state: state, delay: delay)
+    end
+
+    def default_allocate_delay
+      config_get_default('fabricpath', 'allocate_delay')
+    end
+
+    def auto_switch_id
+      config_get('fabricpath', 'auto_switch_id')
+    end
+
+    def graceful_merge
+      graceful_merge_conf = config_get('fabricpath', 'graceful_merge')
+      # opposite meaning with the cli
+      return :enable if graceful_merge_conf.nil?
+      graceful_merge_conf ? :disable : :enable
+    end
+
+    def graceful_merge=(val)
+      state = val == :enable ? 'no' : ''
+      config_set('fabricpath', 'graceful_merge', state: state)
+    end
+
+    def default_graceful_merge
+      graceful_merge = config_get_default('fabricpath', 'graceful_merge')
+      graceful_merge.to_sym
+    end
+
+    def linkup_delay
+      config_get('fabricpath', 'linkup_delay')
+    end
+
+    def linkup_delay=(val)
+      state = val ? '' : 'no'
+      delay = val ? val : ''
+      config_set('fabricpath', 'linkup_delay', state: state, delay: delay)
+    end
+
+    def default_linkup_delay
+      config_get_default('fabricpath', 'linkup_delay')
+    end
+
+    def linkup_delay_always
+      config_get('fabricpath', 'linkup_delay_always')
+    end
+
+    def linkup_delay_always=(val)
+      if val == '' || val == true
+        state = ''
+      else
+        state = 'no'
+      end
+      config_set('fabricpath', 'linkup_delay_always', state: state)
+    end
+
+    def default_linkup_delay_always
+      config_get_default('fabricpath', 'linkup_delay_always')
+    end
+
+    def linkup_delay_enable
+      delay = config_get('fabricpath', 'linkup_delay_enable')
+      return false if delay.nil?
+      delay
+    end
+
+    def linkup_delay_enable=(val)
+      if val == '' || val == true
+        state = ''
+      else
+        state = 'no'
+      end
+      config_set('fabricpath', 'linkup_delay_enable', state: state)
+    end
+
+    def default_linkup_delay_enable
+      config_get_default('fabricpath', 'linkup_delay_enable')
+    end
+
+    def loadbalance_algorithm_symmetric_support
+      config_get_default('fabricpath',
+                         'loadbalance_algorithm_symmetric_support')
+    end
+
+    def loadbalance_algorithm
+      algo = config_get('fabricpath', 'loadbalance_algorithm')
+      algo.downcase
+    end
+
+    def loadbalance_algorithm=(val)
+      val = loadbalance_munge('loadbalance_algorithm', val)
+      state = val ? '' : 'no'
+      algo = val ? val : ''
+      config_set('fabricpath', 'loadbalance_algorithm', state: state,
+                                                        algo:  algo)
+    end
+
+    def default_loadbalance_algorithm
+      config_get_default('fabricpath', 'loadbalance_algorithm')
+    end
+
+    def loadbalance_multicast_rotate
+      config_get('fabricpath', 'loadbalance_multicast_rotate')
+    end
+
+    def loadbalance_multicast_has_vlan
+      val = config_get('fabricpath', 'loadbalance_multicast_has_vlan')
+      val.nil? ? false : val
+    end
+
+    def loadbalance_multicast=(rotate, has_vlan)
+      if rotate == '' && (has_vlan == '' || has_vlan == false)
+        config_set('fabricpath', 'loadbalance_multicast_reset')
+      else
+        rotate = loadbalance_munge('loadbalance_multicast_rotate', rotate)
+        has_vlan = (has_vlan == true) ? 'include-vlan' : ''
+        config_set('fabricpath', 'loadbalance_multicast_set',
+                   rotate: rotate, has_vlan: has_vlan)
+      end
+    end
+
+    # default_loadbalance_multicast_rotate: n/a
+
+    def default_loadbalance_multicast_has_vlan
+      config_get_default('fabricpath', 'loadbalance_multicast_has_vlan')
+    end
+
+    def loadbalance_unicast_layer
+      unicast = config_get('fabricpath', 'loadbalance_unicast_layer')
+      return default_loadbalance_unicast_layer if unicast.nil?
+      case unicast
+      when /L4/
+        'layer4'
+      when /L3/
+        'layer3'
+      when /Mixed/
+        'mixed'
+      end
+    end
+
+    def loadbalance_unicast_rotate
+      config_get('fabricpath', 'loadbalance_unicast_rotate')
+    end
+
+    def loadbalance_unicast_has_vlan
+      val = config_get('fabricpath', 'loadbalance_unicast_has_vlan')
+      val.nil? ? false : val
+    end
+
+    def split_loadbalance_unicast_layer=(val)
+      state = val ? '' : 'no'
+      layer = val ? val : ''
+      config_set('fabricpath', 'loadbalance_unicast_layer',
+                 state: state, layer: layer)
+    end
+
+    def split_loadbalance_unicast_has_vlan=(val)
+      if val == '' || val == false
+        state = 'no'
+      else
+        state = ''
+      end
+      config_set('fabricpath', 'loadbalance_unicast_has_vlan', state: state)
+    end
+
+    def loadbalance_unicast=(layer, rotate, has_vlan)
+      support = config_get('fabricpath', 'loadbalance_unicast_support')
+      if support == 'combined'
+        if layer == '' && rotate == '' && (has_vlan == '' || has_vlan == false)
+          config_set('fabricpath', 'loadbalance_unicast_reset')
+        else
+          rotate = loadbalance_munge('loadbalance_unicast_rotate', rotate)
+          has_vlan = (has_vlan == true) ? 'include-vlan' : ''
+          config_set('fabricpath', 'loadbalance_unicast_set',
+                     layer: layer, rotate: rotate, has_vlan: has_vlan)
+        end
+      else
+        self.split_loadbalance_unicast_layer = layer
+        self.split_loadbalance_unicast_has_vlan = has_vlan
+      end
+    end
+
+    def default_loadbalance_unicast_layer
+      config_get_default('fabricpath', 'loadbalance_unicast_layer')
+    end
+
+    # default_loadbalance_unicast_rotate: n/a
+
+    def default_loadbalance_unicast_has_vlan
+      config_get_default('fabricpath', 'loadbalance_unicast_has_vlan')
+    end
+
+    def mode
+      config_get('fabricpath', 'mode')
+    end
+
+    def mode=(val)
+      if val == '' || val == 'normal'
+        state = 'no'
+      else
+        state = ''
+      end
+      config_set('fabricpath', 'mode', state: state)
+    end
+
+    def default_mode
+      config_get_default('fabricpath', 'mode')
+    end
+
+    def switch_id
+      switch_id_conf = config_get('fabricpath', 'switch_id')
+      return auto_switch_id if switch_id_conf.nil?
+      switch_id_conf
+    end
+
+    def switch_id=(val)
+      # There is no no-form for this command
+      config_set('fabricpath', 'switch_id', swid: val.to_s)
+    end
+
+    def transition_delay
+      config_get('fabricpath', 'transition_delay')
+    end
+
+    def transition_delay=(val)
+      state = val ? '' : 'no'
+      delay = val ? val : ''
+      config_set('fabricpath', 'transition_delay', state: state, delay: delay)
+    end
+
+    def default_transition_delay
+      config_get_default('fabricpath', 'transition_delay')
+    end
+
+    def ttl_multicast
+      config_get('fabricpath', 'ttl_multicast')
+    end
+
+    def ttl_multicast=(val)
+      state = val ? '' : 'no'
+      ttl = val ? val : ''
+      config_set('fabricpath', 'ttl_multicast', state: state, ttl: ttl)
+    end
+
+    def default_ttl_multicast
+      config_get_default('fabricpath', 'ttl_multicast')
+    end
+
+    def ttl_unicast
+      config_get('fabricpath', 'ttl_unicast')
+    end
+
+    def ttl_unicast=(val)
+      state = val ? '' : 'no'
+      ttl = val ? val : ''
+      config_set('fabricpath', 'ttl_unicast', state: state, ttl: ttl)
+    end
+
+    def default_ttl_unicast
+      config_get_default('fabricpath', 'ttl_unicast')
+    end
+  end # class
+end # module