rbeapi 0.3.0 → 0.4.0

data/lib/rbeapi/api/interfaces.rb

@@ -155,7 +155,7 @@ module Rbeapi
       # @return [Hash<Symbol, Object>] resource hash attribute
       def parse_shutdown(config)
         value = /no shutdown/ =~ config
-        { shutdown: value.nil?  }
+        { shutdown: value.nil? }
       end
       private :parse_shutdown
 
@@ -640,7 +640,7 @@ module Rbeapi
       def parse_members(name)
         grpid = name.scan(/(?<=Port-Channel)\d+/)[0]
         command = "show port-channel #{grpid} all-ports"
-        config = node.enable(command, format: 'text')
+        config = node.enable(command, encoding: 'text')
         values = config.first[:result]['output'].scan(/\bEthernet[^\s]+/)
         { members: values }
       end
@@ -664,7 +664,7 @@ module Rbeapi
         return { lacp_mode: DEFAULT_LACP_MODE } unless members
         config = get_block("interface #{members.first}")
         mdata = /channel-group \d+ mode (\w+)/.match(config)
-        { lacp_mode: mdata ? mdata[1] : DEFAULT_LACP_MODE  }
+        { lacp_mode: mdata ? mdata[1] : DEFAULT_LACP_MODE }
       end
       private :parse_lacp_mode
 
@@ -911,8 +911,7 @@ module Rbeapi
       # @param [Hash] :opts optional keyword arguments
       #
       # @option :opts [String] :value Specifies the value to configure for
-      #   the port-channel lacp fallback timeout.  Valid values range from
-      #   1 to 100 seconds
+      #   the port-channel lacp fallback timeout.
       #
       # @option :opts [Boolean] :enable If false then the command is
       #   negated. Default is true.

data/lib/rbeapi/api/radius.rb

@@ -148,7 +148,7 @@ module Rbeapi
       # @return [Array<Hash<Symbol,Object>>] Array of resource hashes
       def parse_servers
         tuples = config.scan(SERVER_REGEXP)
-        tuples.map do |(host, vrf,  authp, acctp, tout, tries, keyfm, key)|
+        tuples.map do |(host, vrf, authp, acctp, tout, tries, keyfm, key)|
           hsh = {}
           hsh[:hostname]         = host
           hsh[:vrf]              = vrf

data/lib/rbeapi/api/routemaps.rb

@@ -43,63 +43,431 @@ module Rbeapi
     # the basis of such criteria as route metrics, access control lists, next
     # hop addresses, and route tags.
     #
-    # rubocop:disable Metrics/MethodLength
+    # rubocop:disable Metrics/ClassLength
     #
     class Routemaps < Entity
+      ##
+      # get returns a hash of routemap configurations for the given name
+      #
+      # @example
+      #   {
+      #     <action>: {
+      #       <seqno>: {
+      #         match: <array>,
+      #         set: <array>,
+      #         continue: <integer>,
+      #         description: <string>
+      #       },
+      #       <seqno>: {
+      #         match: <array>,
+      #         set: <array>,
+      #         continue: <integer>,
+      #         description: <string>
+      #       }
+      #     },
+      #     <action>: {
+      #       <seqno>: {
+      #         match: <array>,
+      #         set: <array>,
+      #         continue: <integer>,
+      #         description: <string>
+      #       },
+      #       <seqno>: {
+      #         match: <array>,
+      #         set: <array>,
+      #         continue: <integer>,
+      #         description: <string>
+      #       }
+      #     }
+      #   }
+      #
+      # @param [String] name The routemap name to return a resource for from the
+      #   nodes configuration
+      #
+      # @return [nil, Hash<Symbol, Object>] Returns the routemap resource as a
+      #   Hash. If the specified name is not found in the nodes current
+      #   configuration a nil object is returned
       def get(name)
+        parse_entries(name)
+      end
+
+      ##
+      # getall returns a collection of routemap resource hashes from the nodes
+      # running configuration. The routemap resource collection hash is keyed
+      # by the unique routemap name.
+      #
+      # @example
+      #   {
+      #     <name>: {
+      #       <action>: {
+      #         <seqno>: {
+      #           match: <array>,
+      #           set: <array>,
+      #           continue: <integer>,
+      #           description: <string>
+      #         },
+      #         <seqno>: {
+      #           match: <array>,
+      #           set: <array>,
+      #           continue: <integer>,
+      #           description: <string>
+      #         }
+      #       },
+      #       <action>: {
+      #         <seqno>: {
+      #           match: <array>,
+      #           set: <array>,
+      #           continue: <integer>,
+      #           description: <string>
+      #         },
+      #         <seqno>: {
+      #           match: <array>,
+      #           set: <array>,
+      #           continue: <integer>,
+      #           description: <string>
+      #         }
+      #       }
+      #     },
+      #     <name>: {
+      #       <action>: {
+      #         <seqno>: {
+      #           match: <array>,
+      #           set: <array>,
+      #           continue: <integer>,
+      #           description: <string>
+      #         },
+      #         <seqno>: {
+      #           match: <array>,
+      #           set: <array>,
+      #           continue: <integer>,
+      #           description: <string>
+      #         }
+      #       },
+      #       <action>: {
+      #         <seqno>: {
+      #           match: <array>,
+      #           set: <array>,
+      #           continue: <integer>,
+      #           description: <string>
+      #         },
+      #         <seqno>: {
+      #           match: <array>,
+      #           set: <array>,
+      #           continue: <integer>,
+      #           description: <string>
+      #         }
+      #       }
+      #     }
+      #   }
+      #
+      # @return [nil, Hash<Symbol, Object>] returns a hash that represents the
+      #   entire routemap collection from the nodes running configuration.  If
+      #   there are no routemap names configured, this method will return nil.
+      def getall
+        routemaps = config.scan(/(?<=^route-map\s)[^\s]+/)
+        return nil if routemaps.empty?
+        routemaps.each_with_object({}) do |name, response|
+          response[name] = parse_entries(name)
+        end
+      end
+
+      ##
+      # parse entries is a private method to get the routemap rules.
+      #
+      # @return [nil, Hash<Symbol, Object>] returns a hash that represents the
+      #   rules for routemaps from the nodes running configuration.  If
+      #   there are no routemaps configured, this method will return nil.
+      #
+      def parse_entries(name)
         entries = config.scan(/^route-map\s#{name}\s.+$/)
+        return nil if entries.empty?
+        entries.each_with_object({}) do |rm, response|
+          mdata = /^route-map\s(.+)\s(.+)\s(\d+)$/.match(rm)
+          rule_hsh = parse_rules(get_block(rm))
+          if response[mdata[2]]
+            response[mdata[2]].merge!(mdata[3].to_i => rule_hsh)
+          else
+            response[mdata[2]] = { mdata[3].to_i => rule_hsh }
+          end
+        end
+      end
+      private :parse_entries
+
+      ##
+      # parse rule is a private method to parse a rule.
+      #
+      # @return [Hash<Symbol, Object>] returns a hash that represents the
+      #   rules for routemaps from the nodes running configuration.  If
+      #   there are no routemaps configured, this method will return an empty
+      #    hash.
+      #
+      def parse_rules(rules)
+        rules.split("\n").each_with_object({}) do |rule, rule_hsh|
+          mdata = /\s{3}(\w+)\s/.match(rule)
+          case mdata.nil? ? nil : mdata[1]
+          when 'match'
+            rule_hsh[:match] = [] unless rule_hsh.include?(:match)
+            rule_hsh[:match] << rule.sub('match', '').strip
+          when 'set'
+            rule_hsh[:set] = [] unless rule_hsh.include?(:set)
+            rule_hsh[:set] << rule.sub('set', '').strip
+          when 'continue'
+            rule_hsh[:continue] = nil unless rule_hsh.include?(:continue)
+            rule_hsh[:continue] = rule.sub('continue', '').strip.to_i
+          when 'description'
+            rule_hsh[:description] = nil unless rule_hsh.include?(:description)
+            rule_hsh[:description] = rule.sub('description', '').strip
+          end
+        end
+      end
+      private :parse_rules
 
-        entries.each_with_object([]) do |rm, arry|
-          mdata = /route-map\s(.+)\s(.+)\s(\d+)$/.match(rm)
-          rules = get_block(rm)
-          rule_hsh = { 'action' => mdata[2], 'seqno' => mdata[3],
-                       'match_rules' => [], 'set_rules' => [],
-                       'continue_rules' => [] }
+      ##
+      # name_commands is utilized to initially prepare the routemap
+      def name_commands(name, action, seqno, opts = {})
+        if opts[:default] == true
+          cmd = "default route-map #{name}"
+        elsif opts[:enable] == false
+          cmd = "no route-map #{name}"
+        else
+          cmd = "route-map #{name}"
+        end
+        cmd << " #{action}"
+        cmd << " #{seqno}"
+        [cmd]
+      end
+      private :name_commands
 
-          parsed = rules.split("\n").each_with_object({}) do |rule, hsh|
-            mdata = /\s{3}(\w+)\s/.match(rule)
-            case mdata.nil? ? nil : mdata[1]
-            when 'match'
-              hsh['match_rules'] = [] unless hsh.include?('match')
-              hsh['match_rules'] << rule.strip
-            when 'set'
-              hsh['set_rules'] = [] unless hsh.include?('set')
-              hsh['set_rules'] << rule.strip
-            when 'continue'
-              hsh['continue_rules'] = [] unless hsh.include?('continue')
-              hsh['continue_rules'] << rule.strip
+      ##
+      # create will create a new routemap with the specified name.
+      #
+      # rubocop:disable Metrics/MethodLength
+      #
+      # @commands
+      #   route-map <name> action <value> seqno <value> description <value>
+      #   match <value> set <value> continue <value>
+      #
+      # @param [String] :name The name of the routemap to create
+      #
+      # @param [String] :action Either permit or deny
+      #
+      # @param [Integer] :seqno The sequence number
+      #
+      # @param [hash] :opts Optional keyword arguments
+      #
+      # @option :opts [Boolean] :default Set routemap to default
+      #
+      # @option :opts [String] :description A description for the routemap
+      #
+      # @option :opts [Array] :match routemap match rule
+      #
+      # @option :opts [String] :set Sets route attribute
+      #
+      # @option :opts [String] :continue The routemap sequence number to
+      #   continue on.
+      #
+      # @option :opts [Boolean] :enable If false then the command is
+      #   negated. Default is true.
+      #
+      # @option :opts [Boolean] :default Configure the routemap to default.
+      #
+      # @return [Boolean] returns true if the command completed successfully
+      def create(name, action, seqno, opts = {})
+        if opts.empty?
+          cmds = name_commands(name, action, seqno)
+        else
+          cmds = name_commands(name, action, seqno, opts)
+          if opts[:description]
+            cmds << 'no description'
+            cmds << "description #{opts[:description]}"
+          end
+          if opts[:continue]
+            cmds << 'no continue'
+            cmds << "continue #{opts[:continue]}"
+          end
+          if opts[:match]
+            remove_match_statements(name, action, seqno, cmds)
+            opts[:match].each do |options|
+              cmds << "match #{options}"
+            end
+          end
+          if opts[:set]
+            remove_set_statements(name, action, seqno, cmds)
+            opts[:set].each do |options|
+              cmds << "set #{options}"
             end
           end
-          rule_hsh.update(parsed)
-          arry << rule_hsh
         end
+        configure(cmds)
       end
 
-      def getall
-        maps = config.scan(/(?<=^route-map\s)[^\s]+/)
-        maps.each_with_object({}) do |name, hsh|
-          hsh[name] = get name unless hsh.include?(name)
+      ##
+      # remove_match_statemements removes all match rules for the
+      # specified routemap
+      def remove_match_statements(name, action, seqno, cmds)
+        entries = parse_entries(name)
+        return nil unless entries
+        entries.each do |entry|
+          next unless entry[0] == action && entry[1].assoc(seqno) && \
+                      entry[1].assoc(seqno)[0] == seqno
+          Array(entry[1].assoc(seqno)[1][:match]).each do |options|
+            cmds << "no match #{options}"
+          end
         end
       end
+      private :remove_match_statements
 
-      def create(name)
-        configure "route-map #{name}"
+      ##
+      # remove_set_statemements removes all set rules for the
+      # specified routemap
+      def remove_set_statements(name, action, seqno, cmds)
+        entries = parse_entries(name)
+        return nil unless entries
+        entries.each do |entry|
+          next unless entry[0] == action && entry[1].assoc(seqno) && \
+                      entry[1].assoc(seqno)[0] == seqno
+          Array(entry[1].assoc(seqno)[1][:set]).each do |options|
+            cmds << "no set #{options}"
+          end
+        end
       end
+      private :remove_set_statements
 
-      def delete(name)
-        configure "no route-map #{name}"
+      ##
+      # delete will delete an existing routemap name from the nodes current
+      # running configuration. If the delete method is called and the
+      # routemap name does not exist, this method will succeed.
+      #
+      # @commands
+      #   no route-map <name> <action> <seqno>
+      #
+      # @param [String] :name The routemap name to delete from the node.
+      #
+      # @param [String] :action Either permit or deny
+      #
+      # @param [Integer] :seqno The sequence number
+      #
+      # @return [Boolean] returns true if the command completed successfully
+      def delete(name, action, seqno)
+        configure(["no route-map #{name} #{action} #{seqno}"])
+      end
+
+      ##
+      # This method will attempt to default the routemap from the nodes
+      # operational config. Since routemaps do not exist by default,
+      # the default action is essentially a negation and the result will
+      # be the removal of the routemap clause.
+      # If the routemap does not exist then this
+      # method will not perform any changes but still return True
+      #
+      # @commands
+      #   no route-map <name>
+      #
+      # @param [String] :name The routemap name to set to default.
+      #
+      # @param [String] :action Either permit or deny
+      #
+      # @param [Integer] :seqno The sequence number
+      #
+      # @return [Boolean] returns true if the command completed successfully
+      def default(name, action, seqno)
+        configure(["default route-map #{name} #{action} #{seqno}"])
+      end
+
+      ##
+      # set_match_statements will set the match values for a specified routemap.
+      # If the specified routemap does not exist, it will be created.
+      #
+      # @commands
+      #   route-map <name> action <value> seqno <value> match <value>
+      #
+      # @param [String] :name The name of the routemap to create
+      #
+      # @param [String] :action Either permit or deny
+      #
+      # @param [Integer] :seqno The sequence number
+      #
+      # @param [Array] :value The routemap match rules
+      #
+      # @return [Boolean] returns true if the command completed successfully
+      def set_match_statements(name, action, seqno, value)
+        cmds = ["route-map #{name} #{action} #{seqno}"]
+        remove_match_statements(name, action, seqno, cmds)
+        Array(value).each do |options|
+          cmds << "match #{options}"
+        end
+        configure(cmds)
+      end
+
+      ##
+      # set_set_statements will set the set values for a specified routemap.
+      # If the specified routemap does not exist, it will be created.
+      #
+      # @commands
+      #   route-map <name> action <value> seqno <value> set <value>
+      #
+      # @param [String] :name The name of the routemap to create
+      #
+      # @param [String] :action Either permit or deny
+      #
+      # @param [Integer] :seqno The sequence number
+      #
+      # @param [Array] :value The routemap set rules
+      #
+      # @return [Boolean] returns true if the command completed successfully
+      def set_set_statements(name, action, seqno, value)
+        cmds = ["route-map #{name} #{action} #{seqno}"]
+        remove_set_statements(name, action, seqno, cmds)
+        Array(value).each do |options|
+          cmds << "set #{options}"
+        end
+        configure(cmds)
       end
 
-      def add_rule(name, action, rule, seqno = nil)
-        cmd = "route-map #{name} #{action}"
-        cmd << " #{seqno}" if seqno
-        cmds = [*cmds]
-        cmds << rule
-        configure cmds
+      ##
+      # set_continue will set the continue value for a specified routemap.
+      # If the specified routemap does not exist, it will be created.
+      #
+      # @commands
+      #   route-map <name> action <value> seqno <value> continue <value>
+      #
+      # @param [String] :name The name of the routemap to create
+      #
+      # @param [String] :action Either permit or deny
+      #
+      # @param [Integer] :seqno The sequence number
+      #
+      # @param [Integer] :value The continue value
+      #
+      # @return [Boolean] returns true if the command completed successfully
+      def set_continue(name, action, seqno, value)
+        cmds = ["route-map #{name} #{action} #{seqno}"]
+        cmds << 'no continue'
+        cmds << "continue #{value}"
+        configure(cmds)
       end
 
-      def remove_rule(name, action, seqno)
-        configure "no route-map #{name} #{action} #{seqno}"
+      ##
+      # set_description will set the description for a specified routemap.
+      # If the specified routemap does not exist, it will be created.
+      #
+      # @commands
+      #   route-map <name> action <value> seqno <value> description <value>
+      #
+      # @param [String] :name The name of the routemap to create
+      #
+      # @param [String] :action Either permit or deny
+      #
+      # @param [Integer] :seqno The sequence number
+      #
+      # @param [String] :value The description value
+      #
+      # @return [Boolean] returns true if the command completed successfully
+      def set_description(name, action, seqno, value)
+        cmds = ["route-map #{name} #{action} #{seqno}"]
+        cmds << 'no description'
+        cmds << "description #{value}"
+        configure(cmds)
       end
     end
   end

data/lib/rbeapi/api/system.rb

@@ -54,6 +54,7 @@ module Rbeapi
       def get
         response = {}
         response.merge!(parse_hostname(config))
+        response.merge!(parse_iprouting(config))
         response
       end
 
@@ -62,6 +63,11 @@ module Rbeapi
         { hostname: mdata.nil? ? '' : mdata[1] }
       end
 
+      def parse_iprouting(config)
+        mdata = /no\sip\srouting/.match(config)
+        { iprouting: mdata.nil? ? true : false }
+      end
+
       ##
       # Configures the system hostname value in the running-config
       #
@@ -76,6 +82,21 @@ module Rbeapi
         cmd = command_builder('hostname', opts)
         configure(cmd)
       end
+
+      ##
+      # Configures the state of global ip routing
+      #
+      # @param [Hash] opts The configuration parameters
+      # @option :opts [Boolean] :enable True if ip routing should be enabled
+      #  or False if ip routing should be disabled. Default is true.
+      # @option opts [Boolean] :default Controls the use of the default
+      #  keyword. Default is false.
+      #
+      # @return [Boolean] returns true if the command completed successfully
+      def set_iprouting(opts = {})
+        cmd = command_builder('ip routing', opts)
+        configure(cmd)
+      end
     end
   end
 end