cisco_node_utils 1.2.0 → 1.3.0

data/lib/cisco_node_utils/constants.rb

@@ -0,0 +1,33 @@
+# January 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.
+
+# Shared constants for the Cisco module
+module Cisco
+  PLATFORMS = [
+    # Cisco IOS XR
+    :ios_xr,
+    # Cisco NX-OS (Nexus switches)
+    :nexus,
+  ]
+
+  DATA_FORMATS = [
+    # Cisco CLI. Indentation is significant.
+    :cli,
+    # Structured data format specific to NX-API
+    :nxapi_structured,
+    # TODO: :yang,
+  ]
+end

data/lib/cisco_node_utils/encapsulation.rb

@@ -0,0 +1,112 @@
+# NXAPI implementation of encapsulation profile class
+#
+# March 2016, Rohan Gandhi Korlepara
+#
+# 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 'feature'
+
+module Cisco
+  # Encapsulation - node utility class for Encapsulation config mgmt.
+  class Encapsulation < NodeUtil
+    attr_reader :encap_name
+
+    # name: name of the encap instance
+    # instantiate: true = create encap instance
+    def initialize(name, instantiate=true)
+      fail ArgumentError unless name.length > 0
+      @encap_name = name
+      create if instantiate
+    end
+
+    def to_s
+      "Encapsulation #{encap_name}"
+    end
+
+    # Create a hash of all current encap instances.
+    def self.encaps
+      return {} unless Feature.vni_enabled?
+      instances = config_get('encapsulation', 'all_encaps')
+      return {} if instances.nil?
+      hash = {}
+      instances.each do |name|
+        hash[name] = Encapsulation.new(name, false)
+      end
+      hash
+    end
+
+    # This will expand the string to a list of bds as integers
+    def self.string_to_array(string)
+      list = []
+      narray = string.split(',')
+      narray.each do |elem|
+        if elem.include?('-')
+          es = elem.gsub('-', '..')
+          ea = es.split('..').map { |d| Integer(d) }
+          er = ea[0]..ea[1]
+          list << er.to_a
+        else
+          list << elem.to_i
+        end
+      end
+      list.flatten
+    end
+
+    # Enable feature and create encap instance
+    def create
+      Feature.vni_enable
+      config_set('encapsulation', 'create', profile: @encap_name)
+    end
+
+    # Destroy an encap instance
+    def destroy
+      config_set('encapsulation', 'destroy', profile: @encap_name)
+    end
+
+    # ----------
+    # PROPERTIES
+    # ----------
+
+    def range_summarize(string)
+      Utils.array_to_str(Encapsulation.string_to_array(string.to_s), false)
+    end
+
+    def dot1q_map
+      result = config_get('encapsulation', 'dot1q_map', profile: @encap_name)
+      return default_dot1q_map if result.empty?
+
+      result[0] = range_summarize(result[0])
+      result[1] = range_summarize(result[1])
+      result
+    end
+
+    def dot1q_map=(map)
+      state = ''
+      if map.empty?
+        state = 'no'
+        map = dot1q_map
+        return if map.empty?
+      end
+      vlans, vnis = map
+      config_set('encapsulation', 'dot1q_map', profile: @encap_name,
+                 state: state, vlans: vlans, vnis: vnis)
+    end
+
+    def default_dot1q_map
+      config_get_default('encapsulation', 'dot1q_map')
+    end
+  end
+end

data/lib/cisco_node_utils/environment.rb

@@ -0,0 +1,102 @@
+# 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 'yaml'
+require_relative 'logger'
+
+module Cisco
+  # Class representing the configuration environment
+  class Environment
+    @environments = {}
+    @default_environment_name = 'default'
+
+    # Autogenerate Cisco::Environment.default_environment_name and
+    # Cisco::Environment.default_environment_name= class methods.
+    class << self
+      attr_accessor :default_environment_name
+    end
+
+    # We have three tiers of configuration:
+    # 1) default (defined in this file)
+    # 2) System-wide gem configuration in /etc/cisco_node_utils.yaml
+    # 3) User configuration in ~/cisco_node_utils.yaml
+
+    DEFAULT_ENVIRONMENT = {
+      host:     nil, # localhost by default
+      port:     nil, # only applicable to gRPC
+      username: nil,
+      password: nil,
+    }
+
+    def self.environments
+      if @environments.empty?
+        @environments = merge_config('/etc/cisco_node_utils.yaml',
+                                     @environments)
+        @environments = merge_config('~/cisco_node_utils.yaml',
+                                     @environments)
+        @environments.each do |name, config|
+          Cisco::Logger.debug("Environment '#{name}': #{config}")
+        end
+      end
+      @environments
+    end
+
+    def self.merge_config(path, current_config)
+      data = data_from_file(path)
+      data.each do |name, config|
+        # in case config is nil:
+        config ||= {}
+        # in case current_config has no entry for this name:
+        current_config[name] ||= DEFAULT_ENVIRONMENT.clone
+        # merge it on in!
+        current_config[name].merge!(strings_to_symbols(config))
+      end
+      current_config
+    end
+
+    def self.data_from_file(path)
+      begin
+        path = File.expand_path(path)
+      rescue ArgumentError => e
+        # Can happen if path includes '~' but $HOME is not defined
+        Cisco::Logger.debug "Failed to load #{path}: #{e}"
+        return {}
+      end
+      unless File.file?(path)
+        Cisco::Logger.debug "No file found at #{path}"
+        return {}
+      end
+      unless File.readable?(path)
+        Cisco::Logger.debug "No permissions to read #{path}"
+        return {}
+      end
+      YAML.load_file(path)
+    rescue Psych::SyntaxError => e
+      Cisco::Logger.error("Error loading #{path}: #{e}")
+      {}
+    end
+
+    def self.strings_to_symbols(hash)
+      Hash[hash.map { |k, v| [k.to_sym, v] }]
+    end
+
+    def self.environment(name=nil)
+      name ||= @default_environment_name
+      Cisco::Logger.debug("Getting environment '#{name}'")
+      environments.fetch(name, DEFAULT_ENVIRONMENT)
+    end
+  end
+end

data/lib/cisco_node_utils/evpn_vni.rb

@@ -84,11 +84,13 @@ module Cisco
     def route_distinguisher=(rd)
       if rd == default_route_distinguisher
         @set_args[:state] = 'no'
-        @set_args[:rd] = ''
+        # I2 images require an rd for removal
+        rd = route_distinguisher
+        return if rd.to_s.empty?
       else
         @set_args[:state] = ''
-        @set_args[:rd] = rd
       end
+      @set_args[:rd] = rd
       config_set('evpn_vni', 'route_distinguisher', @set_args)
       set_args_keys_default
     end
@@ -143,7 +145,7 @@ module Cisco
       delta_hash = Utils.delta_add_remove(should, is)
       return if delta_hash.values.flatten.empty?
       [:add, :remove].each do |action|
-        CiscoLogger.debug("#{prop}" \
+        Cisco::Logger.debug("#{prop}" \
           "#{@get_args}\n #{action}: #{delta_hash[action]}")
         delta_hash[action].each do |community|
           state = (action == :add) ? '' : 'no'

data/lib/cisco_node_utils/exceptions.rb

@@ -0,0 +1,111 @@
+# 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
+
+  # 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

@@ -18,6 +18,7 @@
 # limitations under the License.
 
 require_relative 'node_util'
+require_relative 'vdc'
 
 module Cisco
   # node_utils class for fabricpath_global
@@ -33,23 +34,49 @@ module Cisco
 
     def self.globals
       hash = {}
-      is_fabricpath_feature = config_get('fabricpath', 'feature')
-      return hash if (:enabled != is_fabricpath_feature.to_sym)
+      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')
-      fail 'fabricpath_feature not found' if fabricpath.nil?
       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',
@@ -68,8 +95,7 @@ module Cisco
     end
 
     def create
-      FabricpathGlobal.fabricpath_feature_set(:enabled) unless
-      :enabled == FabricpathGlobal.fabricpath_feature
+      FabricpathGlobal.fabricpath_enable
     end
 
     def destroy
@@ -77,22 +103,15 @@ module Cisco
       FabricpathGlobal.fabricpath_feature_set(:disabled)
     end
 
-    def my_munge(property, set_val)
-      val = config_get_default('fabricpath', property)
+    def loadbalance_munge(property, set_val)
       case property
       when /loadbalance_algorithm/
-        if (val == 'source-destination') &&
-           (set_val == 'symmetric' || set_val == 'xor')
-          val
-        else
-          set_val
-        end
+        val = config_get_default('fabricpath', property)
+        return val if (val == 'source-destination') && set_val[/symmetric|xor/]
+        set_val
       when /loadbalance_.*_rotate/
-        if val == false || set_val == ''
-          ''
-        else
-          "rotate-amount 0x#{set_val.to_s(16)}"
-        end
+        return '' if set_val == ''
+        "rotate-amount 0x#{set_val.to_i.to_s(16)}"
       else
         set_val
       end
@@ -200,13 +219,18 @@ module Cisco
       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 = my_munge('loadbalance_algorithm', val)
+      val = loadbalance_munge('loadbalance_algorithm', val)
       state = val ? '' : 'no'
       algo = val ? val : ''
       config_set('fabricpath', 'loadbalance_algorithm', state: state,
@@ -230,16 +254,14 @@ module Cisco
       if rotate == '' && (has_vlan == '' || has_vlan == false)
         config_set('fabricpath', 'loadbalance_multicast_reset')
       else
-        rotate = my_munge('loadbalance_multicast_rotate', rotate)
+        rotate = loadbalance_munge('loadbalance_multicast_rotate', rotate)
         has_vlan = (has_vlan == true) ? 'include-vlan' : ''
         config_set('fabricpath', 'loadbalance_multicast_set',
-                   rotate_amt: rotate, inc_vlan: has_vlan)
+                   rotate: rotate, has_vlan: has_vlan)
       end
     end
 
-    def default_loadbalance_multicast_rotate
-      config_get_default('fabricpath', 'loadbalance_multicast_rotate')
-    end
+    # default_loadbalance_multicast_rotate: n/a
 
     def default_loadbalance_multicast_has_vlan
       config_get_default('fabricpath', 'loadbalance_multicast_has_vlan')
@@ -269,9 +291,9 @@ module Cisco
 
     def split_loadbalance_unicast_layer=(val)
       state = val ? '' : 'no'
-      pref = val ? val : ''
-      config_set('fabricpath', 'loadbalance_unicast_layer', state: state,
-                                                            pref:  pref)
+      layer = val ? val : ''
+      config_set('fabricpath', 'loadbalance_unicast_layer',
+                 state: state, layer: layer)
     end
 
     def split_loadbalance_unicast_has_vlan=(val)
@@ -289,10 +311,10 @@ module Cisco
         if layer == '' && rotate == '' && (has_vlan == '' || has_vlan == false)
           config_set('fabricpath', 'loadbalance_unicast_reset')
         else
-          rotate = my_munge('loadbalance_unicast_rotate', rotate)
+          rotate = loadbalance_munge('loadbalance_unicast_rotate', rotate)
           has_vlan = (has_vlan == true) ? 'include-vlan' : ''
           config_set('fabricpath', 'loadbalance_unicast_set',
-                     pref: layer, rotate_amt: rotate, inc_vlan: has_vlan)
+                     layer: layer, rotate: rotate, has_vlan: has_vlan)
         end
       else
         self.split_loadbalance_unicast_layer = layer
@@ -304,9 +326,7 @@ module Cisco
       config_get_default('fabricpath', 'loadbalance_unicast_layer')
     end
 
-    def default_loadbalance_unicast_rotate
-      config_get_default('fabricpath', 'loadbalance_unicast_rotate')
-    end
+    # default_loadbalance_unicast_rotate: n/a
 
     def default_loadbalance_unicast_has_vlan
       config_get_default('fabricpath', 'loadbalance_unicast_has_vlan')
@@ -321,9 +341,6 @@ module Cisco
         state = 'no'
       else
         state = ''
-        vdc = config_get('limit_resource', 'vdc')
-        # for vdc unsupported platforms, this will be nil
-        config_set('limit_resource', 'fabricpath_transit', vdc) unless vdc.nil?
       end
       config_set('fabricpath', 'mode', state: state)
     end