cisco_node_utils 1.2.0 → 1.3.0

data/lib/cisco_node_utils/bridge_domain_vni.rb

@@ -0,0 +1,206 @@
+# NXAPI implementation of BridgeDomainVNI class
+#
+# February 2016, Rohan Gandhi Korlepara
+#
+# 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 'feature'
+
+module Cisco
+  # node_utils class for bridge_domain_vni
+  class BridgeDomainVNI < NodeUtil
+    attr_reader :bd_ids, :bd_ids_list
+
+    def initialize(bds, instantiate=true)
+      # Spaces are removed as bridge-domain cli doesn't accept value with
+      # space
+      @bd_ids = bds.to_s.gsub(/\s+/, '')
+      fail 'bridge-domain value is empty' if @bd_ids.empty? # no empty strings
+
+      @bd_ids_list = BridgeDomainVNI.string_to_array(@bd_ids)
+      create if instantiate
+    end
+
+    def to_s
+      "Bridge Domain #{bd_ids}"
+    end
+
+    def self.range_bds
+      hash = {}
+      bd_list = config_get('bridge_domain_vni', 'range_bds')
+      return hash if bd_list.nil?
+
+      bd_list.each do |id|
+        hash[id] = BridgeDomainVNI.new(id, 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
+
+    # Example clis;
+    # system bridge-domain 101-200
+    # bridge-domain 101-200
+    # bridge-domain 101-110,120,141-145,180
+    #   member vni 6001-6011,5041-5044,8000,9000
+    #
+    # config_get('bridge_domain_vni', 'member_vni')
+    # will get the current member vni in this case
+    # 6001-6011,5041-5044,8000,9000
+    #
+    # config_get('bridge_domain_vni', 'member_vni_bd')
+    # will get the current bd's mapped to member vni in this case
+    # 101-110,120,141-145,180
+    #
+    # The @bd_ids_list which is created when the BridgeDomainVNI object is
+    # initialized which could be 101-110 bd range.
+    # hash_map will have 101=>6001,102=>6002...120=>6011,141=>5041...180=>9000
+    # And the final_bd_vni hash will be based of the initialized list
+    # 101=>6001,102=>6002,103=>6003....110=>6010 only.
+    def curr_bd_vni_hash
+      final_bd_vni = {}
+      curr_vni = config_get('bridge_domain_vni', 'member_vni')
+      curr_bd_vni = config_get('bridge_domain_vni', 'member_vni_bd')
+      return final_bd_vni if curr_vni.empty? || curr_bd_vni.empty?
+
+      curr_vni_list = BridgeDomainVNI.string_to_array(curr_vni)
+      curr_bd_vni_list = BridgeDomainVNI.string_to_array(curr_bd_vni)
+
+      hash_map = Hash[curr_bd_vni_list.zip(curr_vni_list.map)]
+      @bd_ids_list.each do |bd|
+        final_bd_vni[bd.to_i] = hash_map[bd.to_i] if hash_map.key?(bd.to_i)
+      end
+      final_bd_vni
+    end
+
+    # This function will first add bds to the system bridge-domain and then
+    # create the bds. If bds already existing then just create. Else add the
+    # non added bds to system range first then create all. This is to avoid the
+    # idempotency issue as system add command throws error if a bd is already
+    # present in the system range.
+    def create
+      sys_bds_array = BridgeDomainVNI.string_to_array(system_bridge_domain)
+      if (@bd_ids_list - sys_bds_array).any?
+        add_bds = Utils
+                  .array_to_str((@bd_ids_list - sys_bds_array), false)
+        config_set('bridge_domain_vni', 'system_bridge_domain', oper: 'add',
+                                                                bd:   add_bds)
+      end
+      config_set('bridge_domain_vni', 'create', bd: @bd_ids)
+    end
+
+    def destroy
+      bd_vni = curr_bd_vni_hash
+      bd_val = bd_vni.keys.join(',')
+      vni_val = bd_vni.values.join(',')
+      return '' if vni_val.empty?
+      config_set('bridge_domain_vni', 'member_vni', bd: bd_val,
+                 membstate: 'no', membvni: vni_val)
+      config_set('bridge_domain_vni', 'vni', state: 'no', vni: vni_val)
+    end
+
+    ########################################################
+    #                      PROPERTIES                      #
+    ########################################################
+
+    # Bridge-Domain member vni assigning case
+    # Not all the bds created or initialized in this class context can have the
+    # member vni's mapped. So will get the vnis of the ones which are mapped to
+    # the bds.
+    # Eg: Suppose the bd mapping is as below on the switch
+    # bridge-domain 100,105,107-109,150
+    #   member vni 5000, 8000, 5007-5008, 7000, 5050
+    # If puppet layer tries to get values of 100,105,107 bds as defined in
+    # manifest then the final_bd_vni map which is returned will contain only
+    # these mappings as below;
+    # '5000,8000,5007'
+    # This is also to handle the idempotence case, and if any mismatch then set
+    # the member_vni
+    def member_vni
+      bd_vni_hash = curr_bd_vni_hash
+      ret_list = []
+      @bd_ids_list.each do |bd|
+        ret_list << bd_vni_hash[bd]
+      end
+      Utils.array_to_str(ret_list, false)
+    end
+
+    # This member_vni mapping will be executed only when the val is not empty
+    # else it will be treated as a 'no' cli and executed as required.
+    # If the mappings do not match in any fashion then cli normally returns a
+    # failure which will be handled.
+    # During set of member vni we first see if any bd is mapped to some other
+    # vni, if yes then remove that one and apply the new vni.
+    # Eg: bridge-domain 100-110
+    #       member vni 5100-5110
+    # Now the manifest is changed to 5100-5105,6106-6110, so hence first
+    # 5106-5110 mapping is removed and then 6106-6110 is applied.
+    def member_vni=(val)
+      val = val.to_s
+      Feature.vni_enable
+      bd_vni = curr_bd_vni_hash
+      if val.empty?
+        bd_val = bd_vni.keys.join(',')
+        vni_val = bd_vni.values.join(',')
+        return '' if vni_val.empty?
+        config_set('bridge_domain_vni', 'member_vni', bd: bd_val,
+                   membstate: 'no', membvni: vni_val)
+        config_set('bridge_domain_vni', 'vni', state: 'no', vni: vni_val)
+      else
+        unless bd_vni.empty?
+          inp_vni_list = BridgeDomainVNI.string_to_array(val.to_s)
+          inp_bd_vni_hash = Hash[@bd_ids_list.zip(inp_vni_list)]
+
+          temp_hash = bd_vni.to_a.keep_if { |k, _v| inp_bd_vni_hash.key? k }
+          rem_hash = (temp_hash.to_a - inp_bd_vni_hash.to_a).to_h
+
+          rm_bd = rem_hash.keys.join(',')
+          rm_vni = rem_hash.values.join(',')
+          config_set('bridge_domain_vni', 'member_vni', bd: rm_bd,
+                     membstate: 'no', membvni: rm_vni)
+          config_set('bridge_domain_vni', 'vni', state: 'no', vni: rm_vni)
+        end
+        config_set('bridge_domain_vni', 'vni', state: '', vni: val)
+        config_set('bridge_domain_vni', 'member_vni', bd: @bd_ids,
+                   membstate: '', membvni: val)
+      end
+    end
+
+    def default_member_vni
+      config_get_default('bridge_domain_vni', 'member_vni')
+    end
+
+    # getter for system bridge-domain
+    def system_bridge_domain
+      config_get('bridge_domain_vni', 'system_bridge_domain')
+    end
+  end  # Class
+end    # Module

data/lib/cisco_node_utils/cisco_cmn_utils.rb

@@ -24,11 +24,11 @@ module Cisco
     # password encryption types
     def self.cli_to_symbol(cli)
       case cli
-      when '0', 0
+      when '0', 0, 'clear'
         :cleartext
       when '3', 3
         :"3des" # yuck :-(
-      when '5', 5
+      when '5', 5, 'encrypted'
         :md5
       when '6', 6
         :aes
@@ -96,6 +96,13 @@ module Cisco
   # General utility class
   class Utils
     require 'ipaddr'
+
+    # Helper utility to check for older Nexus I2 images
+    def self.nexus_i2_image
+      require_relative 'platform'
+      true if Platform.image_version[/7.0.3.I2/]
+    end
+
     # Helper utility method for ip/prefix format networks.
     # For ip/prefix format '1.1.1.1/24' or '2000:123:38::34/64',
     # we need to mask the address using the prefix length so that they
@@ -117,6 +124,9 @@ module Cisco
     end
 
     def self.delta_add_remove(should, current=[], opt=nil)
+      current = [] if current.nil?
+      should = [] if should.nil?
+
       # Remove nil entries from array
       should.each(&:compact!) if depth(should) > 1
       delta = { add: should - current, remove: current - should }
@@ -126,6 +136,8 @@ module Cisco
 
       # Delete entries from :remove if f1 is an update to an existing command
       delta[:add].each do |id, _|
+        # Differentiate between comparing nested and unnested arrays by
+        # checking the depth of the array.
         if depth(should) == 1
           delta[:remove].delete_if { |f1| [f1] if f1.to_s == id.to_s }
         else
@@ -135,11 +147,82 @@ module Cisco
       delta
     end # delta_add_remove
 
+    def self.length_to_bitmask(length)
+      IPAddr.new('255.255.255.255').mask(length).to_s
+    end
+
+    def self.bitmask_to_length(bitmask)
+      # Convert bitmask to a 32-bit integer,
+      # convert that to binary, and count the 1s
+      IPAddr.new(bitmask).to_i.to_s(2).count('1')
+    rescue IPAddr::InvalidAddressError => e
+      raise ArgumentError, "bitmask '#{bitmask}' is not valid: #{e}"
+    end
+
     # Helper to 0-pad a mac address.
     def self.zero_pad_macaddr(mac)
       return nil if mac.nil? || mac.empty?
       o1, o2, o3 = mac.split('.').map { |o| o.to_i(16).to_s(10) }
       sprintf('%04x.%04x.%04x', o1, o2, o3)
     end
+
+    # For spanning tree range based parameters, the range
+    # is very dynamic and so before the parameters are set,
+    # the rest of the range needs to be reset
+    # For ex: if the ranges 2-42 and 83-200 are getting set,
+    # and the total range of the given parameter is 1-4000
+    # then 1,43-82,201-4000 needs to be reset. This method
+    # takes the set ranges and gives back the range to be reset
+    def self.get_reset_range(total_range, remove_ranges)
+      fail 'invalid range' unless total_range.include?('-')
+      return total_range if remove_ranges.empty?
+
+      trs = total_range.gsub('-', '..')
+      tra = trs.split('..').map { |d| Integer(d) }
+      tr = tra[0]..tra[1]
+      tarray = tr.to_a
+      remove_ranges.each do |rr, _val|
+        rarray = rr.gsub('-', '..').split(',')
+        rarray.each do |elem|
+          if elem.include?('..')
+            elema = elem.split('..').map { |d| Integer(d) }
+            ele = elema[0]..elema[1]
+            tarray -= ele.to_a
+          else
+            tarray.delete(elem.to_i)
+          end
+        end
+      end
+      Utils.array_to_str(tarray)
+    end
+
+    # This method converts an array to string form
+    # for ex: if the array has 1, 2 to 10, 83 to 2014, 3022
+    # and the string will be "1,2-10,83-2014,3022"
+    def self.array_to_str(array, sort=true)
+      farray = sort ? array.compact.uniq.sort : array.compact
+      lranges = []
+      unless farray.empty?
+        l = array.first
+        r = nil
+        farray.each do |aelem|
+          if r && aelem != r.succ
+            if l == r
+              lranges << l
+            else
+              lranges << Range.new(l, r)
+            end
+            l = aelem
+          end
+          r = aelem
+        end
+        if l == r
+          lranges << l
+        else
+          lranges << Range.new(l, r)
+        end
+      end
+      lranges.to_s.gsub('..', '-').delete('[').delete(']').delete(' ')
+    end
   end # class Utils
 end   # module Cisco

data/lib/cisco_node_utils/client.rb

@@ -0,0 +1,35 @@
+# Copyright (c) 2015 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.
+
+# Namespace for Cisco-specific code
+module Cisco
+  # Namespace for Cisco Client shim
+  class Client
+  end
+end
+
+require_relative 'client/client'
+
+# Try to load known extensions
+extensions = ['client/nxapi',
+              'client/grpc',
+             ]
+extensions.each do |ext|
+  begin
+    require_relative ext
+  rescue LoadError => e
+    # ignore missing client-(grpc|nxapi), they're not always required
+    raise unless e.message =~ /#{Regexp.escape(ext)}/
+  end
+end

data/lib/cisco_node_utils/client/client.rb

@@ -0,0 +1,234 @@
+#!/usr/bin/env ruby
+#
+# October 2015, Glenn F. Matthews
+#
+# 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 '../environment'
+require_relative '../exceptions'
+require_relative 'utils'
+require_relative '../constants'
+require_relative '../logger'
+
+include Cisco::Logger
+
+# Base class for clients of various RPC formats
+class Cisco::Client
+  @@clients = [] # rubocop:disable Style/ClassVars
+
+  def self.clients
+    @@clients
+  end
+
+  # Each subclass should call this method to register itself.
+  def self.register_client(client)
+    @@clients << client
+  end
+
+  attr_reader :data_formats, :platform
+
+  def initialize(data_formats: [],
+                 platform:     nil,
+                 **kwargs)
+    if self.class == Cisco::Client
+      fail NotImplementedError, 'Cisco::Client is an abstract class. ' \
+        "Instantiate one of #{@@clients} or use Cisco::Client.create() instead"
+    end
+    self.class.validate_args(**kwargs)
+    @host = kwargs[:host]
+    @port = kwargs[:port]
+    @address = @port.nil? ? @host : "#{@host}:#{@port}"
+    @username = kwargs[:username]
+    @password = kwargs[:password]
+    self.data_formats = data_formats
+    self.platform = platform
+    @cache_enable = true
+    @cache_auto = true
+    cache_flush
+  end
+
+  def self.validate_args(**kwargs)
+    host = kwargs[:host]
+    unless host.nil?
+      fail TypeError, 'invalid address' unless host.is_a?(String)
+      fail ArgumentError, 'empty address' if host.empty?
+    end
+    username = kwargs[:username]
+    unless username.nil?
+      fail TypeError, 'invalid username' unless username.is_a?(String)
+      fail ArgumentError, 'empty username' if username.empty?
+    end
+    password = kwargs[:password]
+    unless password.nil?
+      fail TypeError, 'invalid password' unless password.is_a?(String)
+      fail ArgumentError, 'empty password' if password.empty?
+    end
+  end
+
+  def supports?(data_format)
+    data_formats.include?(data_format)
+  end
+
+  # Try to create an instance of an appropriate subclass
+  def self.create(environment_name=nil)
+    fail 'No client implementations available!' if clients.empty?
+    debug "Trying to establish client connection. clients = #{clients}"
+    environment = Cisco::Environment.environment(environment_name)
+    host = environment[:host]
+    errors = []
+    clients.each do |client_class|
+      begin
+        debug "Trying to connect to #{host} as #{client_class}"
+        client = client_class.new(**environment)
+        debug "#{client_class} connected successfully"
+        return client
+      rescue Cisco::ClientError, TypeError, ArgumentError => e
+        debug "Unable to connect to #{host} as #{client_class}: #{e.message}"
+        debug e.backtrace.join("\n  ")
+        errors << e
+      end
+    end
+    handle_errors(errors)
+  end
+
+  def self.handle_errors(errors)
+    # ClientError means we tried to connect but failed,
+    # so it's 'more significant' than input validation errors.
+    client_errors = errors.select { |e| e.kind_of? Cisco::ClientError }
+    if !client_errors.empty?
+      # Reraise the specific error if just one
+      fail client_errors[0] if client_errors.length == 1
+      # Otherwise clump them together into a new error
+      e_cls = client_errors[0].class
+      unless client_errors.all? { |e| e.class == e_cls }
+        e_cls = Cisco::ClientError
+      end
+      fail e_cls, ("Unable to establish any client connection:\n" +
+                   errors.each(&:message).join("\n"))
+    elsif errors.any? { |e| e.kind_of? ArgumentError }
+      fail ArgumentError, ("Invalid arguments:\n" +
+                           errors.each(&:message).join("\n"))
+    elsif errors.any? { |e| e.kind_of? TypeError }
+      fail TypeError, ("Invalid arguments:\n" +
+                       errors.each(&:message).join("\n"))
+    end
+    fail Cisco::ClientError, 'No client connected, but no errors were reported?'
+  end
+
+  def to_s
+    @address.to_s
+  end
+
+  def inspect
+    "<#{self.class} of #{@address}>"
+  end
+
+  def cache_enable?
+    @cache_enable
+  end
+
+  def cache_enable=(enable)
+    @cache_enable = enable
+    cache_flush unless enable
+  end
+
+  def cache_auto?
+    @cache_auto
+  end
+
+  attr_writer :cache_auto
+
+  # Clear the cache of CLI output results.
+  #
+  # If cache_auto is true (default) then this will be performed automatically
+  # whenever a set() is called, but providers may also call this
+  # to explicitly force the cache to be cleared.
+  def cache_flush
+    # to be implemented by subclasses
+  end
+
+  # Configure the given state on the device.
+  #
+  # @raise [RequestNotSupported] if this client doesn't support the given
+  #   data_format
+  #
+  # @param data_format one of Cisco::DATA_FORMATS. Default is :cli
+  # @param context [String, Array<String>] Context for the configuration
+  # @param values [String, Array<String>] Actual configuration to set
+  def set(data_format: :cli,
+          context:     nil,
+          values:      nil)
+    # subclasses will generally want to call Client.munge_to_array()
+    # on context and/or values before calling super()
+    fail Cisco::RequestNotSupported unless self.supports?(data_format)
+    cache_flush if cache_auto?
+    Cisco::Logger.debug("Set state using data format '#{data_format}'")
+    Cisco::Logger.debug("  with context:\n    #{context.join("\n    ")}") \
+      unless context.nil? || context.empty?
+    Cisco::Logger.debug("  to value(s):\n    #{values.join("\n    ")}") \
+      unless values.nil? || values.empty?
+    # to be implemented by subclasses
+  end
+
+  # Get the given state from the device.
+  #
+  # Unlike set() this will not clear the CLI cache;
+  # multiple calls with the same parameters may return cached data
+  # rather than querying the device repeatedly.
+  #
+  # @raise [RequestNotSupported] if the client doesn't support the data_format
+  # @raise [RequestFailed] if the command is rejected by the device
+  #
+  # @param data_format one of Cisco::DATA_FORMATS. Default is :cli
+  # @param command [String] the get command to execute
+  # @param context [String, Array<String>] Context to refine/filter the results
+  # @param value [String, Regexp] Specific key or regexp to look up
+  # @return [String, Hash, nil] The state found, or nil if not found.
+  def get(data_format: :cli,
+          command:     nil,
+          context:     nil,
+          value:       nil)
+    # subclasses will generally want to call Client.munge_to_array()
+    # on context and/or value before calling super()
+    fail Cisco::RequestNotSupported unless self.supports?(data_format)
+    Cisco::Logger.debug("Get state using data format '#{data_format}'")
+    Cisco::Logger.debug("  executing command:\n    #{command}") \
+      unless command.nil? || command.empty?
+    Cisco::Logger.debug("  with context:\n    #{context.join("\n    ")}") \
+      unless context.nil? || context.empty?
+    Cisco::Logger.debug("  to get value:     #{value}") \
+      unless value.nil?
+    # to be implemented by subclasses
+  end
+
+  private
+
+  # Set the list of data formats supported by this client.
+  # If the client supports multiple formats, and a given feature or property
+  # can be managed by multiple formats, the list order indicates preference.
+  def data_formats=(data_formats)
+    data_formats = [data_formats] unless data_formats.is_a?(Array)
+    unknown = data_formats - Cisco::DATA_FORMATS
+    fail ArgumentError, "unknown data formats: #{unknown}" unless unknown.empty?
+    @data_formats = data_formats
+  end
+
+  # Set the platform of the node managed by this client.
+  def platform=(platform)
+    fail ArgumentError, "unknown platform #{platform}" \
+      unless Cisco::PLATFORMS.include?(platform)
+    @platform = platform
+  end
+end