RubyGems - vtysh - Versions diffs - 0.1.0 → 0.2.1 - Mend

vtysh 0.1.0 → 0.2.1

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (4) hide show

checksums.yaml CHANGED Viewed

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 379ae72d0d97bf2292c0d3b303799a44efcbf35d282628c5ab0ce3f7e49814be
-  data.tar.gz: 87dfb517f5840af6c423ebad534865911598e54835bc1108825eccd0f66f4358
+  metadata.gz: 34af7b512a21982b0dc323bbfc0552909980573621430434dea7906f84c2cf84
+  data.tar.gz: 9b087692d112485f5dd6adcdff7ac1d9915e4276036c88ecba98860e495e16bb
 SHA512:
-  metadata.gz: ba2974e8ff1b4afa191d0d2fac607521d101829a573c2b855c23766cbb0c5e1d141d05296768c9287b6cfbd3e87b5054dc4f61c50dacfbf11752e9c19d6200e8
-  data.tar.gz: dee8353a63b67879f848265ba70cb7d5f9becd1780e255d22ab78861a69f1611a94a888eb1cc0eb3e5880535448d2e97ef4d4fbb7d7ea74acf319586ab5aa1c8
+  metadata.gz: 4ebe4a05ea96de7d365b4171b97d47e1544b1c6b23c0a81eba074d884af669b6e753732cf5d606aa72bf346d0e382229f913a25401a2328b0c3f4b0aa68d9bcc
+  data.tar.gz: 4eaa1c86dc0a01e5ba84c4515b8d9ff216511c015a9f4fb0ce865b95f8e6e83eb49ce2a16cfcb08b595ec89ba600bc603dd717c9d21562e0923bd576e4b96972

data/lib/vtysh/diff.rb CHANGED Viewed

@@ -1,324 +1,227 @@
 module Vtysh
   class Diff
     def self.commands(source, target)
-      # Parse configurations into flat commands
       source_cmds = parse_config(source)
       target_cmds = parse_config(target)
-      # Generate commands to transform source to target
-      commands = []
-      # Special case for router-id changes
       if needs_bgp_recreation?(source_cmds, target_cmds)
-        commands.concat(handle_bgp_recreation(source_cmds, target_cmds))
+        bgp_commands = handle_bgp_recreation(source_cmds, target_cmds)
+        non_bgp_commands = handle_non_bgp_changes(source_cmds, target_cmds, skip_bgp_blocks: true)
+        bgp_commands + non_bgp_commands
       else
-        # Handle removals first (items in source but not in target)
-        (source_cmds - target_cmds).each do |cmd|
-          if is_block_command(cmd[:command])
-            # For block commands like "router bgp X", we need to remove the whole block
-            commands << format_removal_command(cmd)
-            # Skip commands inside this block - they'll be removed automatically
-            if cmd[:command].start_with?("router bgp")
-              # We need to specifically exclude commands inside this removed BGP block
-              # to avoid generating individual "no" commands for them
-              asn = cmd[:command].split[2]
-              # Don't generate commands for items in this block
-            end
-          elsif cmd[:depth] > 0
-            # Check if we're removing a command inside a block that's already being removed
-            block_being_removed = false
-            cmd[:context].each do |ctx|
-              # Check if any of the contexts is a block that's being removed
-              if source_cmds.any? { |s| s[:command] == ctx && (source_cmds - target_cmds).include?(s) }
-                block_being_removed = true
-                break
-              end
-            end
-            # Only generate a command if not inside a block that's being removed
-            unless block_being_removed
-              # For commands inside blocks, we need to provide the proper context
-              commands << format_context_command("no #{cmd[:command]}", cmd[:context])
-            end
-          else
-            # For top-level commands
-            commands << "vtysh -c \"configure\" -c \"no #{cmd[:command]}\""
-          end
-        end
-        # Handle additions (items in target but not in source)
-        (target_cmds - source_cmds).each do |cmd|
-          if is_block_command(cmd[:command])
-            # For block commands like "router bgp X", include the block creation
-            commands << "vtysh -c \"configure\" -c \"#{cmd[:command]}\""
-          elsif cmd[:depth] > 0
-            # For commands inside blocks, we need to provide the proper context
-            commands << format_context_command(cmd[:command], cmd[:context])
-          else
-            # For top-level commands
-            commands << "vtysh -c \"configure\" -c \"#{cmd[:command]}\""
-          end
-        end
+        handle_non_bgp_changes(source_cmds, target_cmds) +
+          handle_incremental_bgp_changes(source_cmds, target_cmds)
       end
-      # Sort commands and apply dependency-based reordering
-      reorder_commands(commands.uniq)
     end
     private
-    # New improved command ordering function that ensures the proper order for BGP-related commands
-    def self.reorder_commands(commands)
-      # First extract all the commands that need to be properly ordered
-      all_peer_group_cmds = commands.select { |cmd| cmd.include?("neighbor") && cmd.include?("peer-group") && !cmd.include?("no ") }
-      all_remote_as_cmds = commands.select { |cmd| cmd.include?("remote-as") }
-      all_listen_range_cmds = commands.select { |cmd| cmd.include?("bgp listen range") }
-      # Need to remove these from commands for proper reordering
-      clean_commands = commands - all_peer_group_cmds - all_remote_as_cmds - all_listen_range_cmds
-      # Apply correct ordering for all commands
-      final_commands = []
-      # Handle prefix-lists first (always)
-      prefix_list_cmds = clean_commands.select { |cmd| cmd.include?("ip prefix-list") }
-      final_commands.concat(prefix_list_cmds)
-      # Handle route-map definitions second
-      route_map_cmds = clean_commands.select { |cmd| cmd.include?("route-map") && !cmd.include?("neighbor") && !cmd.include?("no ") }
-      final_commands.concat(route_map_cmds)
-      # Include router bgp blocks
-      bgp_block_cmds = clean_commands.select { |cmd| cmd.include?("router bgp") && !cmd.include?("no ") && cmd.count("\"") <= 6 }
-      final_commands.concat(bgp_block_cmds)
-      # Now add peer-group commands first
-      all_peer_group_cmds.sort.each do |cmd|
-        final_commands << cmd
-      end
-      # Then add remote-as commands
-      all_remote_as_cmds.sort.each do |cmd|
-        final_commands << cmd
+    def self.handle_non_bgp_changes(source_cmds, target_cmds, skip_bgp_blocks: false)
+      commands = []
+      # Removals (non-BGP, plus top-level BGP block removals when not recreating)
+      (source_cmds - target_cmds).each do |cmd|
+        next if inside_bgp?(cmd) && !cmd[:command].start_with?("router bgp")
+        next if skip_bgp_blocks && cmd[:command].start_with?("router bgp")
+        if is_block_command(cmd[:command])
+          commands << format_removal_command(cmd)
+        elsif cmd[:depth] > 0
+          next if block_being_removed?(cmd, source_cmds, target_cmds)
+          commands << format_context_command("no #{cmd[:command]}", cmd[:context])
+        else
+          commands << vtysh_cmd("no #{cmd[:command]}")
+        end
       end
-      # Then add listen-range commands
-      all_listen_range_cmds.sort.each do |cmd|
-        final_commands << cmd
+      # Non-BGP additions
+      (target_cmds - source_cmds).each do |cmd|
+        next if inside_bgp?(cmd)
+        if is_block_command(cmd[:command])
+          commands << vtysh_cmd(cmd[:command])
+        elsif cmd[:depth] > 0
+          commands << format_context_command(cmd[:command], cmd[:context])
+        else
+          commands << vtysh_cmd(cmd[:command])
+        end
       end
-      # Add all remaining commands except removals
-      remaining_cmds = clean_commands.select { |cmd| !cmd.include?("no ") }
-      remaining_cmds -= final_commands
-      final_commands.concat(remaining_cmds)
-      # Add removal commands at the end
-      removal_cmds = clean_commands.select { |cmd| cmd.include?("no ") }
-      final_commands.concat(removal_cmds)
-      # Return unique commands with duplicates removed
-      final_commands.uniq
+      reorder_non_bgp(commands)
     end
-    def self.needs_bgp_recreation?(source_cmds, target_cmds)
-      # Get BGP ASNs from both configs
-      source_bgp = source_cmds.select { |cmd| cmd[:command].start_with?("router bgp") }
-      target_bgp = target_cmds.select { |cmd| cmd[:command].start_with?("router bgp") }
-      # Check if we have the same ASN in both
-      source_asns = source_bgp.map { |cmd| cmd[:command].split[2] }
-      target_asns = target_bgp.map { |cmd| cmd[:command].split[2] }
-      # If ASNs don't match, no need for special handling
-      return false if source_asns != target_asns || source_asns.empty?
-      # For each ASN that appears in both, check for router-id changes
-      source_asns.each do |asn|
-        # Find router-id in source
-        src_bgp_cmds = source_cmds.select { |cmd|
-          cmd[:depth] > 0 &&
-          cmd[:context].any? { |ctx| ctx.start_with?("router bgp #{asn}") } &&
-          cmd[:command].include?("bgp router-id")
-        }
-        # Find router-id in target
-        tgt_bgp_cmds = target_cmds.select { |cmd|
-          cmd[:depth] > 0 &&
-          cmd[:context].any? { |ctx| ctx.start_with?("router bgp #{asn}") } &&
-          cmd[:command].include?("bgp router-id")
-        }
-        # If both have router-id and they're different, return true
-        if !src_bgp_cmds.empty? && !tgt_bgp_cmds.empty? &&
-           src_bgp_cmds.first[:command] != tgt_bgp_cmds.first[:command]
-          return true
-        end
+    def self.handle_incremental_bgp_changes(source_cmds, target_cmds)
+      commands = []
+      # BGP removals
+      (source_cmds - target_cmds).each do |cmd|
+        next unless inside_bgp?(cmd)
+        next if cmd[:command].start_with?("router bgp") # don't remove the block itself
+        next if block_being_removed?(cmd, source_cmds, target_cmds)
+        commands << format_context_command("no #{cmd[:command]}", cmd[:context])
+      end
+      # BGP additions
+      (target_cmds - source_cmds).each do |cmd|
+        next unless inside_bgp?(cmd)
+        next if cmd[:command].start_with?("router bgp")
+        commands << format_context_command(cmd[:command], cmd[:context])
       end
-      false
+      reorder_bgp(commands)
     end
     def self.handle_bgp_recreation(source_cmds, target_cmds)
+      source_asns = source_cmds.select { |c| c[:command].start_with?("router bgp") }.map { |c| c[:command].split[2] }
+      target_asns = target_cmds.select { |c| c[:command].start_with?("router bgp") }.map { |c| c[:command].split[2] }
       commands = []
-      # Get BGP ASNs
-      source_bgp = source_cmds.select { |cmd| cmd[:command].start_with?("router bgp") }
-      target_bgp = target_cmds.select { |cmd| cmd[:command].start_with?("router bgp") }
-      source_asns = source_bgp.map { |cmd| cmd[:command].split[2] }
-      target_asns = target_bgp.map { |cmd| cmd[:command].split[2] }
-      # For each ASN, recreate the BGP block
       (source_asns & target_asns).each do |asn|
-        # Remove the BGP block
-        commands << "vtysh -c \"configure\" -c \"no router bgp #{asn}\""
-        # Get the commands for this BGP block in the target config
-        target_bgp_block = target_cmds.select { |cmd|
-          cmd[:depth] > 0 && cmd[:context].any? { |ctx| ctx.start_with?("router bgp #{asn}") }
+        bgp_ctx = "router bgp #{asn}"
+        # Step 1: Remove the old BGP block
+        commands << vtysh_cmd("no #{bgp_ctx}")
+        # Step 2: Create the new BGP block
+        commands << vtysh_cmd(bgp_ctx)
+        # Step 3: Add main BGP commands (not inside address-family)
+        target_bgp = target_cmds.select { |c|
+          c[:depth] > 0 &&
+          c[:context].include?(bgp_ctx) &&
+          !c[:context].any? { |ctx| ctx.start_with?("address-family") } &&
+          !is_block_command(c[:command])  # skip block commands (router bgp, address-family)
         }
-        # Add the BGP block itself
-        commands << "vtysh -c \"configure\" -c \"router bgp #{asn}\""
-        # Add commands within the BGP block
-        bgp_main_cmds = target_bgp_block.select { |cmd|
-          !cmd[:context].any? { |ctx| ctx.start_with?("address-family") }
-        }
-        # Sort commands - router-id first, then peer-groups, then remote-as, etc.
-        bgp_main_cmds.sort_by! { |cmd| bgp_command_priority(cmd[:command]) }
-        # Add the main BGP commands
-        bgp_main_cmds.each do |cmd|
-          commands << "vtysh -c \"configure\" -c \"router bgp #{asn}\" -c \"#{cmd[:command]}\""
+        target_bgp.sort_by { |c| bgp_command_priority(c[:command]) }.each do |cmd|
+          commands << vtysh_cmd(bgp_ctx, cmd[:command])
         end
-        # Add address-family blocks and their commands
-        af_contexts = target_bgp_block.map { |cmd|
-          cmd[:context].find { |ctx| ctx.start_with?("address-family") }
-        }.compact.uniq
-        af_contexts.each do |af_ctx|
-          # Add the address-family context
-          commands << "vtysh -c \"configure\" -c \"router bgp #{asn}\" -c \"#{af_ctx}\""
-          # Add commands in this address-family
-          af_cmds = target_bgp_block.select { |cmd| cmd[:context].include?(af_ctx) }
+        # Step 4: Add address-family blocks
+        af_contexts = target_cmds.select { |c|
+          c[:command].start_with?("address-family") && c[:context].include?(bgp_ctx)
+        }.map { |c| c[:command] }.uniq
+        af_contexts.each do |af|
+          commands << vtysh_cmd(bgp_ctx, af)
+          af_cmds = target_cmds.select { |c|
+            c[:depth] > 0 &&
+            c[:context].include?(bgp_ctx) &&
+            c[:context].include?(af) &&
+            c[:command] != af  # skip the address-family command itself
+          }
           af_cmds.each do |cmd|
-            commands << "vtysh -c \"configure\" -c \"router bgp #{asn}\" -c \"#{af_ctx}\" -c \"#{cmd[:command]}\""
+            commands << vtysh_cmd(bgp_ctx, af, cmd[:command])
           end
         end
       end
       commands
     end
+    # --- Helpers ---
+    def self.inside_bgp?(cmd)
+      cmd[:context].any? { |ctx| ctx.start_with?("router bgp") } ||
+        cmd[:command].start_with?("router bgp")
+    end
+    def self.block_being_removed?(cmd, source_cmds, target_cmds)
+      removals = source_cmds - target_cmds
+      cmd[:context].any? { |ctx|
+        is_block_command(ctx) && removals.any? { |r| r[:command] == ctx }
+      }
+    end
+    def self.needs_bgp_recreation?(source_cmds, target_cmds)
+      source_asns = source_cmds.select { |c| c[:command].start_with?("router bgp") }.map { |c| c[:command].split[2] }
+      target_asns = target_cmds.select { |c| c[:command].start_with?("router bgp") }.map { |c| c[:command].split[2] }
+      return false if source_asns != target_asns || source_asns.empty?
+      source_asns.any? do |asn|
+        src_rid = source_cmds.find { |c| c[:command].include?("bgp router-id") && c[:context].any? { |ctx| ctx.include?("router bgp #{asn}") } }
+        tgt_rid = target_cmds.find { |c| c[:command].include?("bgp router-id") && c[:context].any? { |ctx| ctx.include?("router bgp #{asn}") } }
+        src_rid && tgt_rid && src_rid[:command] != tgt_rid[:command]
+      end
+    end
     def self.bgp_command_priority(cmd)
-      # Define priority for BGP commands (lower number = higher priority)
-      if cmd.include?('bgp router-id')
-        return 1  # router-id should be first
-      elsif cmd.include?('neighbor') && cmd.include?('peer-group') && !cmd.include?(' route-map ')
-        return 2  # peer-group definitions second
-      elsif cmd.include?('remote-as')
-        return 3  # remote-as commands next
-      elsif cmd.include?('bgp listen range')
-        return 4  # bgp listen range commands after
-      else
-        return 5  # other commands last
+      case
+      when cmd.include?('bgp router-id') then 1
+      when cmd =~ /neighbor \S+ peer-group$/ then 2
+      when cmd.include?('remote-as') then 3
+      when cmd =~ /neighbor \S+ local-as/ then 4
+      when cmd.include?('bgp listen range') then 5
+      else 6
       end
     end
+    def self.reorder_non_bgp(commands)
+      prefix_lists = commands.select { |c| c.include?("ip prefix-list") }
+      route_maps = commands.select { |c| c.include?("route-map") && !c.include?("no ") }
+      removals = commands.select { |c| c.include?("no ") } - prefix_lists
+      rest = commands - prefix_lists - route_maps - removals
+      (prefix_lists + route_maps + rest + removals).uniq
+    end
+    def self.reorder_bgp(commands)
+      peer_groups = commands.select { |c| c =~ /neighbor \S+ peer-group"$/ && !c.include?("no ") }
+      remote_as = commands.select { |c| c.include?("remote-as") && !c.include?("no ") }
+      listen_range = commands.select { |c| c.include?("bgp listen range") && !c.include?("no ") }
+      removals = commands.select { |c| c.include?("no ") }
+      rest = commands - peer_groups - remote_as - listen_range - removals
+      (peer_groups + remote_as + listen_range + rest + removals).uniq
+    end
+    # --- Parsing ---
     def self.parse_config(config)
-      lines = config.split("\n").map(&:strip)
       commands = []
       context_stack = []
-      lines.each do |line|
+      config.each_line do |line|
+        line = line.strip
         next if line.empty? || line.start_with?('#', '!')
-        if line == 'exit' || line == 'exit-vrf' || line == 'exit-address-family'
-          # Exit the current context
+        next if line.start_with?('ip route ')  # managed by config_db, not vtysh
+        next if line =~ /^frr (version|defaults)/ || line == 'no service integrated-vtysh-config' || line.start_with?('agentx')
+        if line =~ /^exit(-address-family|-vrf)?$/
           context_stack.pop unless context_stack.empty?
         elsif line == 'end'
-          # Exit all contexts
           context_stack = []
         elsif is_block_command(line)
-          # Start a new context block
           context_stack << line
           commands << { command: line, context: context_stack.dup, depth: context_stack.size }
         else
-          # Regular command, may be inside a context
           commands << { command: line, context: context_stack.dup, depth: context_stack.size }
         end
       end
       commands
     end
     def self.is_block_command(cmd)
       cmd.start_with?('router ', 'interface ', 'route-map ', 'vrf ', 'address-family ')
     end
-    def self.needs_exit_command(cmd)
-      cmd.start_with?('router ', 'interface ', 'vrf ')
+    # --- Formatting ---
+    def self.vtysh_cmd(*parts)
+      args = ["configure"] + parts
+      "vtysh " + args.map { |p| "-c \"#{p}\"" }.join(" ")
     end
     def self.format_removal_command(cmd)
-      command = cmd[:command]
-      # For block commands with nested structures
-      if command.start_with?('router bgp')
-        asn = command.split[2]
-        return "vtysh -c \"configure\" -c \"no router bgp #{asn}\""
-      elsif command.start_with?('interface')
-        iface = command.split[1]
-        return "vtysh -c \"configure\" -c \"no interface #{iface}\""
-      elsif command.start_with?('vrf')
-        vrf_name = command.split[1]
-        return "vtysh -c \"configure\" -c \"no vrf #{vrf_name}\""
-      elsif command.start_with?('route-map')
-        parts = command.split
-        if parts.size >= 4
-          return "vtysh -c \"configure\" -c \"no route-map #{parts[1]} #{parts[2]} #{parts[3]}\""
-        else
-          return "vtysh -c \"configure\" -c \"no #{command}\""
-        end
-      else
-        # Generic block removal
-        return "vtysh -c \"configure\" -c \"no #{command}\""
-      end
+      vtysh_cmd("no #{cmd[:command]}")
     end
     def self.format_context_command(command, context)
-      result = "vtysh -c \"configure\""
-      # Add each context element
-      context.each do |ctx|
-        if ctx.start_with?('router bgp')
-          asn = ctx.split[2]
-          result += " -c \"router bgp #{asn}\""
-        elsif ctx.start_with?('interface')
-          iface = ctx.split[1]
-          result += " -c \"interface #{iface}\""
-        elsif ctx.start_with?('address-family')
-          parts = ctx.split
-          if parts.size > 2
-            result += " -c \"address-family #{parts[1]} #{parts[2]}\""
-          else
-            result += " -c \"address-family #{parts[1]}\""
-          end
-        else
-          # Generic context
-          result += " -c \"#{ctx}\""
-        end
-      end
-      # Add the command itself
-      result += " -c \"#{command}\""
-      result
+      parts = context.map { |ctx| ctx }
+      vtysh_cmd(*parts, command)
     end
   end
-end
+end

data/lib/vtysh/version.rb CHANGED Viewed

@@ -1,3 +1,3 @@
 module Vtysh
-  VERSION = "0.1.0"
+  VERSION = "0.2.1"
 end

metadata CHANGED Viewed

@@ -1,14 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: vtysh
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.2.1
 platform: ruby
 authors:
 - Jonathan Siegel
-autorequire:
 bindir: bin
 cert_chain: []
-date: 2025-04-03 00:00:00.000000000 Z
+date: 1980-01-02 00:00:00.000000000 Z
 dependencies: []
 description: A gem that accepts two vtysh configuration states and returns the commands
   needed to transition from one to the other
@@ -28,7 +27,6 @@ homepage: http://github.com/usiegj00/vtysh-gem
 licenses:
 - MIT
 metadata: {}
-post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -43,8 +41,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.5.16
-signing_key:
+rubygems_version: 3.6.9
 specification_version: 4
 summary: Handles SONiC vtysh commandfile format
 test_files: []