vtysh 0.1.0

checksums.yaml

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

data/README.md

@@ -0,0 +1,71 @@
+# Vtysh
+
+A Ruby gem for handling SONiC vtysh configuration diffs. It accepts two configuration states and returns the commands needed to transition from one to the other.
+
+## Installation
+
+```ruby
+gem 'vtysh'
+```
+
+## Usage
+
+```ruby
+require 'vtysh'
+
+source_config = File.read('a.vtysh')
+target_config = File.read('b.vtysh')
+
+commands = Vtysh::Diff.commands(source_config, target_config)
+
+puts commands
+```
+
+This will output commands with proper hierarchy preserved:
+
+```
+# BGP blocks are fully recreated
+vtysh -c "configure" -c "no router bgp 65001"
+vtysh -c "configure" -c "router bgp 65001" -c "bgp router-id 192.168.1.1" -c "neighbor 192.168.1.2 remote-as 65002" -c "exit"
+
+# Individual commands for non-BGP configuration
+vtysh -c "configure" -c "interface Ethernet0 description Primary"
+```
+
+## Features
+
+- Generates hierarchical vtysh commands that maintain proper block structure
+- Properly handles configuration blocks like `router bgp` and `address-family`
+- Removes and recreates entire BGP blocks for clean configuration
+- Route-map match commands are split into separate arguments
+- Adds appropriate exit commands when needed
+- Correctly removes entire configuration blocks with `no` prefix
+- Includes `configure` terminal context as required by SONiC vtysh
+- Ensures `neighbor peer-group` commands come before `bgp listen range` commands
+- Ensures `neighbor remote-as` commands are processed before other neighbor attributes
+
+## Command Ordering
+
+The gem pays special attention to command ordering to meet SONiC vtysh requirements:
+
+1. Peer-group definitions come before `bgp listen range` commands referencing them
+2. For neighbors, `remote-as` commands always come before other attributes like route-maps, descriptions, etc.
+3. When adding new neighbors, the ASN is defined first via the `remote-as` command
+4. This prevents common errors like `% Specify remote-as or peer-group commands first`
+
+## Block-Based Processing
+
+The gem uses a block-based approach where:
+
+1. BGP blocks are fully removed and recreated with clean settings
+2. Route-map blocks handle match commands as separate arguments
+3. Interface and other blocks are processed with proper context
+
+This ensures:
+- Complete configuration with proper command ordering
+- Clean setup of complex structures like BGP routers
+- Proper handling of nested contexts like address-family blocks
+
+## License
+
+The gem is available as open source under the terms of the MIT License. 

data/bin/vtysh-transform

@@ -0,0 +1,31 @@
+#!/usr/bin/env ruby
+
+require 'vtysh'
+
+if ARGV.size != 2
+  puts "Usage: vtysh-transform SOURCE_FILE TARGET_FILE"
+  exit 1
+end
+
+source_file = ARGV[0]
+target_file = ARGV[1]
+
+# Ensure files exist
+unless File.exist?(source_file)
+  puts "Error: Source file #{source_file} does not exist."
+  exit 1
+end
+
+unless File.exist?(target_file)
+  puts "Error: Target file #{target_file} does not exist."
+  exit 1
+end
+
+# Read configurations
+source_config = File.read(source_file)
+target_config = File.read(target_file)
+
+# Generate and print commands
+Vtysh::Diff.commands(source_config, target_config).each do |cmd|
+  puts cmd
+end 

data/lib/vtysh/diff.rb

@@ -0,0 +1,324 @@
+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))
+      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
+      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
+      end
+      
+      # Then add listen-range commands
+      all_listen_range_cmds.sort.each do |cmd|
+        final_commands << cmd
+      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
+    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
+      end
+      
+      false
+    end
+    
+    def self.handle_bgp_recreation(source_cmds, target_cmds)
+      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}") }
+        }
+        
+        # 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]}\""
+        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) }
+          af_cmds.each do |cmd|
+            commands << "vtysh -c \"configure\" -c \"router bgp #{asn}\" -c \"#{af_ctx}\" -c \"#{cmd[:command]}\""
+          end
+        end
+      end
+      
+      commands
+    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
+      end
+    end
+    
+    def self.parse_config(config)
+      lines = config.split("\n").map(&:strip)
+      commands = []
+      context_stack = []
+      
+      lines.each do |line|
+        next if line.empty? || line.start_with?('#', '!')
+        
+        if line == 'exit' || line == 'exit-vrf' || line == 'exit-address-family'
+          # Exit the current context
+          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 ')
+    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
+    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
+    end
+  end
+end 

data/lib/vtysh/version.rb

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

data/lib/vtysh.rb

@@ -0,0 +1,6 @@
+require_relative "vtysh/version"
+require_relative "vtysh/diff"
+
+module Vtysh
+  class Error < StandardError; end
+end 

metadata

@@ -0,0 +1,50 @@
+--- !ruby/object:Gem::Specification
+name: vtysh
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Jonathan Siegel
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2025-04-03 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
+email:
+- "<248302+usiegj00@users.noreply.github.com>"
+executables:
+- vtysh-transform
+extensions: []
+extra_rdoc_files: []
+files:
+- README.md
+- bin/vtysh-transform
+- lib/vtysh.rb
+- lib/vtysh/diff.rb
+- lib/vtysh/version.rb
+homepage: http://github.com/usiegj00/vtysh-gem
+licenses:
+- MIT
+metadata: {}
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 2.6.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.5.16
+signing_key:
+specification_version: 4
+summary: Handles SONiC vtysh commandfile format
+test_files: []