vtysh 0.1.0 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 379ae72d0d97bf2292c0d3b303799a44efcbf35d282628c5ab0ce3f7e49814be
-  data.tar.gz: 87dfb517f5840af6c423ebad534865911598e54835bc1108825eccd0f66f4358
+  metadata.gz: f6a2ab5cedc801c0e0297a423aa742d190e356ebe1b1a5d182acb9931a2a6750
+  data.tar.gz: d4a2f50962fa26c2b1f0fc45aeb1b59fdf2c30ac2be809071fbf42f64a56c9f0
 SHA512:
-  metadata.gz: ba2974e8ff1b4afa191d0d2fac607521d101829a573c2b855c23766cbb0c5e1d141d05296768c9287b6cfbd3e87b5054dc4f61c50dacfbf11752e9c19d6200e8
-  data.tar.gz: dee8353a63b67879f848265ba70cb7d5f9becd1780e255d22ab78861a69f1611a94a888eb1cc0eb3e5880535448d2e97ef4d4fbb7d7ea74acf319586ab5aa1c8
+  metadata.gz: 7fc2560400cac17c55802b0e4c8d9641b6082578ca4644d9378a90781282b7fbec29c7a2d930b05f11c7970020f11b53ef9de2621c0df7d33cbb83cc029b90f0
+  data.tar.gz: ff3396f22ee51f40094f86e9de99b64bba9e4f338b13cd15545d703f7473d8566439d065aaa829ad325a061e7e161cbec87b10dd383474b152fe5c04812269bd

data/lib/vtysh/diff.rb

@@ -1,324 +1,225 @@
 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
+
+        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

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

metadata

@@ -1,14 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: vtysh
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.2.0
 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: []