vagrant-ssh-config-manager 0.8.2

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: e1bd8cef21dfadbeaed3204b702d00203c2b30581a6ad27c370d5679a661e594
+  data.tar.gz: 2ce4b4be6a99bdfc0c978c3fda2af091e37f80cebca628bb317cc52ac19266a9
+SHA512:
+  metadata.gz: c314ed1a2dfcfb02dee0c09e4cabb3b36f8f6423685388f34632dd707545c8d9408178db0c63617cd789dd7115cd115d37fefed57b8b619500fd55ded0e35ccf
+  data.tar.gz: 62de37425bece9d76e6f756ccdf71ac52c7c03a46258222412a3993151297d24ae4d8eb7929b33a1407c3b7f0fbc53aaa9608262fee4d7ea22169a39f967ac9b

data/.bundle/config

@@ -0,0 +1,2 @@
+---
+BUNDLE_PATH: "vendor/bundle"

data/.gitignore

@@ -0,0 +1,5 @@
+vendor
+.github/instructions
+test_file
+vagrant-ssh-config-manager-*.gem
+Gemfile.lock

data/Gemfile

@@ -0,0 +1,15 @@
+source "https://rubygems.org"
+
+# Specify your gem's dependencies in vagrant-ssh-config-manager.gemspec
+gemspec
+
+group :development, :test do
+  gem "bundler", "~> 2.0"
+  gem "rake", "~> 13.0"
+  gem "rspec", "~> 3.0"
+  gem "rspec-mocks", "~> 3.0"
+  gem "simplecov", "~> 0.21"
+  gem "rubocop", "~> 1.0"
+  gem "rubocop-rspec", "~> 2.0"
+  gem "vagrant", git: "https://github.com/hashicorp/vagrant.git", tag: "v2.4.1"
+end

data/README.md

@@ -0,0 +1,267 @@
+# Vagrant SSH Config Manager
+
+A Vagrant plugin that automatically manages SSH configuration entries for Vagrant-managed VMs, providing seamless SSH access without the need to remember ports, IPs, or key locations.
+
+## Features
+
+- **Automatic SSH Config Management**: Creates and maintains SSH config files when VMs are started
+- **Project Isolation**: Each Vagrant project gets its own SSH config namespace to avoid conflicts
+- **Separate File Management**: Creates individual SSH config files for each VM in a dedicated directory
+- **Include Directive Management**: Automatically manages Include directives in your main SSH config
+- **Lifecycle Integration**: Hooks into all Vagrant VM lifecycle events (up, destroy, reload, halt, provision)
+- **Configurable Behavior**: Extensive configuration options for different workflows
+- **Robust Error Handling**: Graceful handling of file permission issues and concurrent access
+- **File Locking**: Prevents SSH config corruption during concurrent operations
+- **Backup Support**: Creates backups before modifying SSH config files
+
+## Installation
+
+### Install from RubyGems (Recommended)
+
+```bash
+vagrant plugin install vagrant-ssh-config-manager
+```
+
+### Install from Source
+
+```bash
+git clone https://github.com/your-username/vagrant-ssh-config-manager.git
+cd vagrant-ssh-config-manager
+gem build vagrant-ssh-config-manager.gemspec
+vagrant plugin install vagrant-ssh-config-manager-*.gem
+```
+
+## Quick Start
+
+1. Install the plugin
+2. Add configuration to your `Vagrantfile` (optional)
+3. Run `vagrant up`
+4. Connect to your VM with: `ssh <project>-<machine-name>`
+
+### Example
+
+```ruby
+# Vagrantfile
+Vagrant.configure("2") do |config|
+  config.vm.box = "ubuntu/focal64"
+  
+  # Optional: Configure the plugin (uses sensible defaults)
+  config.sshconfigmanager.enabled = true
+  config.sshconfigmanager.ssh_config_dir = "~/.ssh/config.d/vagrant"
+  config.sshconfigmanager.manage_includes = true
+  
+  config.vm.define "web" do |web|
+    web.vm.network "private_network", ip: "192.168.33.10"
+  end
+end
+```
+
+After `vagrant up`, you can connect with:
+```bash
+ssh vagrant-web  # Project + machine name
+```
+
+## Configuration
+
+All configuration options are available in your `Vagrantfile`:
+
+```ruby
+Vagrant.configure("2") do |config|
+  config.sshconfigmanager.enabled = true                        # Enable/disable plugin (default: true)
+  config.sshconfigmanager.ssh_config_dir = "~/.ssh/config.d/vagrant" # Directory for individual SSH config files (default)
+  config.sshconfigmanager.manage_includes = false               # Manage Include directive in main SSH config (default: false)
+  config.sshconfigmanager.auto_create_dir = true                # Auto-create SSH config dir if missing (default: true)
+  config.sshconfigmanager.cleanup_empty_dir = true              # Remove empty SSH config dir when no VMs remain (default: true)
+  config.sshconfigmanager.auto_remove_on_destroy = true         # Remove SSH entries on VM destroy (default: true)
+  config.sshconfigmanager.update_on_reload = true               # Update SSH entries on VM reload (default: true)
+  config.sshconfigmanager.refresh_on_provision = true           # Refresh SSH entries on VM provision (default: true)
+  config.sshconfigmanager.keep_config_on_halt = true            # Keep SSH entries when VM is halted (default: true)
+  config.sshconfigmanager.project_isolation = true              # Use project-specific naming (default: true)
+end
+```
+
+### Configuration Options
+
+| Option | Type | Default | Description |
+|--------|------|---------|-------------|
+| `enabled` | Boolean | `true` | Enable or disable the plugin globally |
+| `ssh_config_dir` | String | `~/.ssh/config.d/vagrant` | Directory for individual SSH config files |
+| `manage_includes` | Boolean | `false` | Automatically manage Include directive in main SSH config |
+| `auto_create_dir` | Boolean | `true` | Automatically create SSH config directory if it doesn't exist |
+| `cleanup_empty_dir` | Boolean | `true` | Remove empty SSH config directory when no VMs remain |
+| `auto_remove_on_destroy` | Boolean | `true` | Remove SSH entries when VM is destroyed |
+| `update_on_reload` | Boolean | `true` | Update SSH entries when VM is reloaded |
+| `refresh_on_provision` | Boolean | `true` | Refresh SSH entries when VM is provisioned |
+| `keep_config_on_halt` | Boolean | `true` | Keep SSH entries when VM is halted/suspended |
+| `project_isolation` | Boolean | `true` | Use project-specific naming for SSH entries.<br>Set to `false` if using together with `vagrant-hostmanager`.<br>**Be mindful of hostname collisions!** |
+
+## How It Works
+
+### Separate File Architecture (Default)
+
+The plugin creates individual SSH config files for each VM in a dedicated directory (default: `~/.ssh/config.d/vagrant/`). This approach:
+
+- **Prevents conflicts**: Each VM has its own config file
+- **Enables easier cleanup**: Destroying a VM removes only its config file
+- **Supports concurrent operations**: Multiple VMs can be managed simultaneously
+- **Maintains cleaner config**: Main SSH config stays uncluttered
+
+### SSH Config Structure
+
+```
+~/.ssh/config                           # Your main SSH config
+~/.ssh/config.d/vagrant/                # Plugin-managed directory
+  ├── a1b2c3d4-web.conf                # Individual VM config files
+  ├── a1b2c3d4-db.conf
+  └── f5e6d7c8-api.conf                # From different projects
+```
+
+### Include Directive Management
+
+When `manage_includes` is enabled (default: false), the plugin automatically adds:
+
+```
+# ~/.ssh/config
+# BEGIN vagrant-ssh-config-manager
+Include ~/.ssh/config.d/vagrant/*.conf
+# END vagrant-ssh-config-manager
+
+# Your existing SSH configuration continues here...
+```
+
+### Project Isolation
+
+Each Vagrant project gets a unique identifier based on the project path:
+- Project path: `/home/user/my-app`
+- Project hash: `a1b2c3d4` (first 8 chars of MD5)
+- SSH host names: `my-app-web`, `my-app-db`
+- Config files: `a1b2c3d4-web.conf`, `a1b2c3d4-db.conf`
+
+### Individual Config File Example
+
+```
+# ~/.ssh/config.d/vagrant/a1b2c3d4-web.conf
+# Managed by vagrant-ssh-config-manager plugin
+# Project: my-app
+# VM: web
+# Generated: 2025-01-01 12:00:00
+
+Host my-app-web
+  HostName 192.168.33.10
+  Port 22
+  User vagrant
+  IdentityFile /home/user/.vagrant.d/insecure_private_key
+  IdentitiesOnly yes
+  UserKnownHostsFile /dev/null
+  StrictHostKeyChecking no
+  PasswordAuthentication no
+  LogLevel FATAL
+```
+
+### Main SSH Config Integration
+
+When `manage_includes` is enabled, the plugin automatically adds an Include directive:
+
+```
+# ~/.ssh/config
+# BEGIN vagrant-ssh-config-manager
+Include ~/.ssh/config.d/vagrant/*.conf
+# END vagrant-ssh-config-manager
+
+# Your existing SSH configuration...
+```
+
+## Usage Examples
+
+### Basic Multi-Machine Setup
+
+```ruby
+Vagrant.configure("2") do |config|
+  config.vm.box = "generic/debian12"
+  
+  config.vm.define "web" do |web|
+    web.vm.network "private_network", ip: "192.168.33.10"
+  end
+  
+  config.vm.define "db" do |db|
+    db.vm.network "private_network", ip: "192.168.33.11"
+  end
+end
+```
+
+Connect to machines:
+```bash
+vagrant up
+ssh vagrant-web
+ssh vagrant-db
+```
+
+### Disable for Specific Environments
+
+```ruby
+Vagrant.configure("2") do |config|
+  # Disable in production environment
+  config.sshconfigmanager.enabled = ENV['VAGRANT_ENV'] != 'production'
+  # ... rest of config
+end
+```
+
+## Troubleshooting
+
+### Common Issues
+
+#### Permission Denied
+```
+SSH config manager: Permission denied. Check file permissions.
+```
+**Solution**: Ensure SSH config file and directory are writable:
+```bash
+chmod 600 ~/.ssh/config
+chmod 700 ~/.ssh
+```
+
+#### File Not Found
+```
+SSH config manager: SSH config file cannot be created
+```
+**Solution**: Ensure SSH directory exists:
+```bash
+mkdir -p ~/.ssh
+chmod 700 ~/.ssh
+```
+
+#### Concurrent Access Issues
+The plugin uses separate ssh config file for each of the servers... there should be no concurrency issues by design.  
+
+
+### Debugging
+
+Enable Vagrant debug output:
+```bash
+VAGRANT_LOG=debug vagrant up
+```
+
+Check plugin logs in the output for SSH config manager operations.
+
+### Manual Cleanup
+
+If you need to manually clean up SSH config entries:
+
+```bash
+# Remove all Vagrant-managed entries
+rm ~/.ssh/config.d/vagrant/*
+
+# Remove include directive from main config
+sed -i '/# BEGIN vagrant-ssh-config-manager/,/# END vagrant-ssh-config-manager/d' ~/.ssh/config
+```
+
+## Compatibility
+
+- **Vagrant**: 2.0+
+- **Ruby**: 2.4+
+- **Platforms**: Linux, macOS, Windows (with WSL)
+- **Providers**: VirtualBox, VMware, Libvirt, Hyper-V, Docker, AWS, and others
+
+## License
+
+MIT License - see [LICENSE](LICENSE) file for details.

data/Rakefile

@@ -0,0 +1,22 @@
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+
+RSpec::Core::RakeTask.new(:spec)
+
+task :default => :spec
+
+desc "Run RuboCop"
+task :rubocop do
+  sh "bundle exec rubocop"
+end
+
+desc "Run RuboCop with auto-correct"
+task :rubocop_fix do
+  sh "bundle exec rubocop -a"
+end
+
+desc "Run tests with coverage"
+task :coverage do
+  ENV['COVERAGE'] = 'true'
+  Rake::Task[:spec].invoke
+end

data/lib/vagrant-ssh-config-manager/action/destroy.rb

@@ -0,0 +1,84 @@
+module VagrantPlugins
+  module SshConfigManager
+    module Action
+      class Destroy
+        def initialize(app, env)
+          @app = app
+          @env = env
+          @logger = Log4r::Logger.new("vagrant::plugins::ssh_config_manager::action::destroy")
+        end
+
+        def call(env)
+          machine = env[:machine]
+          
+          # Handle SSH config removal before destroying the machine
+          if machine
+            config = machine.config.sshconfigmanager
+            if config && config.enabled && config.auto_remove_on_destroy
+              handle_ssh_config_removal(machine, config)
+            end
+          end
+
+          # Call the next middleware (actual destroy)
+          @app.call(env)
+        end
+
+        private
+
+        def handle_ssh_config_removal(machine, config)
+          begin
+            @logger.info("Removing SSH config file for machine: #{machine.name}")
+
+            # Lazy load required classes with error handling
+            begin
+              require 'vagrant-ssh-config-manager/file_manager'
+              require 'vagrant-ssh-config-manager/include_manager'
+            rescue LoadError => e
+              @logger.error("Failed to load required classes: #{e.message}")
+              machine.ui.warn("SSH config manager: Failed to load required components, skipping SSH config removal")
+              return
+            end
+
+            # Create file manager and include manager
+            file_manager = FileManager.new(config)
+            include_manager = IncludeManager.new(config)
+
+            # Check if SSH config file exists
+            unless file_manager.ssh_config_file_exists?(machine)
+              @logger.debug("No SSH config file found for machine: #{machine.name}")
+              machine.ui.info("No SSH config file found to remove for machine: #{machine.name}")
+              return
+            end
+
+            # Remove SSH config file with logging
+            @logger.info("Attempting to remove SSH config file for #{machine.name}")
+            
+            if file_manager.remove_ssh_config_file(machine)
+              machine.ui.info("SSH config file removed for machine '#{machine.name}'")
+              @logger.info("Successfully removed SSH config file for #{machine.name}")
+              
+              # Manage Include directive after file removal
+              include_manager.manage_include_directive
+            else
+              machine.ui.warn("Failed to remove SSH config file for machine: #{machine.name}")
+              @logger.warn("Failed to remove SSH config file for #{machine.name}")
+            end
+
+          rescue Errno::EACCES => e
+            @logger.error("Permission denied accessing SSH config for #{machine.name}: #{e.message}")
+            machine.ui.warn("SSH config manager: Permission denied. Check file permissions.")
+          rescue Errno::EIO => e
+            @logger.error("I/O error for #{machine.name}: #{e.message}")
+            machine.ui.warn("SSH config manager: I/O error accessing SSH config files.")
+          rescue => e
+            @logger.error("Error removing SSH config for #{machine.name}: #{e.message}")
+            @logger.debug("Backtrace: #{e.backtrace.join("\n")}")
+            
+            # Don't fail the vagrant destroy process, just warn
+            machine.ui.warn("SSH config manager encountered an error during cleanup: #{e.message}")
+          end
+        end
+      end
+    end
+  end
+end

data/lib/vagrant-ssh-config-manager/action/halt.rb

@@ -0,0 +1,68 @@
+module VagrantPlugins
+  module SshConfigManager
+    module Action
+      class Halt
+        def initialize(app, env)
+          @app = app
+          @env = env
+          @logger = Log4r::Logger.new("vagrant::plugins::ssh_config_manager::action::halt")
+        end
+
+        def call(env)
+          machine = env[:machine]
+          
+          # Handle SSH config for halt/suspend operations
+          if machine
+            config = machine.config.sshconfigmanager
+            if config && config.enabled && config.keep_config_on_halt
+              handle_ssh_config_for_halt(machine, config, env)
+            end
+          end
+
+          # Call the next middleware (actual halt/suspend)
+          @app.call(env)
+        end
+
+        private
+
+        def handle_ssh_config_for_halt(machine, config, env)
+          begin
+            # Determine the type of operation
+            operation = determine_operation_type(env)
+            @logger.info("Handling SSH config for #{operation} operation on machine: #{machine.name}")
+
+            # With separate files, we keep the SSH config file during halt/suspend
+            # This allows users to quickly resume and reconnect
+            case operation
+            when :halt, :suspend, :poweroff, :force_halt
+              machine.ui.info("Machine #{operation}ed - SSH config file retained")
+              @logger.debug("Keeping SSH config file for #{operation}ed machine: #{machine.name}")
+            else
+              @logger.debug("No SSH config action needed for operation: #{operation}")
+            end
+
+          rescue => e
+            @logger.error("Error handling SSH config for halt/suspend #{machine.name}: #{e.message}")
+            @logger.debug("Backtrace: #{e.backtrace.join("\n")}")
+            
+            # Don't fail the halt/suspend process
+            machine.ui.warn("SSH config manager encountered an error: #{e.message}")
+          end
+        end
+
+        def determine_operation_type(env)
+          # Try to determine what type of halt operation this is
+          if env[:force_halt]
+            :force_halt
+          elsif env[:suspend]
+            :suspend
+          elsif env[:graceful_halt] == false
+            :poweroff
+          else
+            :halt
+          end
+        end
+      end
+    end
+  end
+end

data/lib/vagrant-ssh-config-manager/action/provision.rb

@@ -0,0 +1,82 @@
+module VagrantPlugins
+  module SshConfigManager
+    module Action
+      class Provision
+        def initialize(app, env)
+          @app = app
+          @env = env
+          @logger = Log4r::Logger.new("vagrant::plugins::ssh_config_manager::action::provision")
+        end
+
+        def call(env)
+          # Call the next middleware first (actual provisioning)
+          @app.call(env)
+
+          # Only proceed if the machine is running and SSH is ready
+          machine = env[:machine]
+          return unless machine && machine.state.id == :running
+
+          # Check if plugin is enabled
+          config = machine.config.sshconfigmanager
+          return unless config && config.enabled && config.refresh_on_provision
+
+          # Handle SSH config file refresh after provisioning
+          handle_ssh_config_refresh(machine, config)
+        end
+
+        private
+
+        def handle_ssh_config_refresh(machine, config)
+          begin
+            @logger.info("Refreshing SSH config file after provisioning for machine: #{machine.name}")
+
+            # Lazy load required classes with error handling
+            begin
+              require 'vagrant-ssh-config-manager/ssh_info_extractor'
+              require 'vagrant-ssh-config-manager/file_manager'
+              require 'vagrant-ssh-config-manager/include_manager'
+            rescue LoadError => e
+              @logger.error("Failed to load required classes: #{e.message}")
+              machine.ui.warn("SSH config manager: Failed to load required components, skipping SSH config refresh")
+              return
+            end
+
+            # Extract SSH information
+            extractor = SshInfoExtractor.new(machine)
+            
+            # Check if machine supports SSH
+            unless extractor.ssh_capable?
+              @logger.debug("Machine #{machine.name} does not support SSH, skipping")
+              return
+            end
+
+            # Create file manager and include manager
+            file_manager = FileManager.new(config)
+            include_manager = IncludeManager.new(config)
+
+            # Refresh SSH config file (regenerate it)
+            # Provisioning might have changed SSH configuration
+            if file_manager.write_ssh_config_file(machine)
+              host_name = file_manager.send(:generate_host_name, machine)
+              machine.ui.info("SSH config file refreshed for machine '#{machine.name}' after provisioning")
+              @logger.info("SSH config file refreshed due to provisioning")
+              
+              # Ensure Include directive is managed
+              include_manager.manage_include_directive
+            else
+              machine.ui.warn("Failed to refresh SSH config file for machine: #{machine.name}")
+              @logger.warn("Failed to refresh SSH config file for #{machine.name}")
+            end
+
+          rescue => e
+            @logger.error("Error refreshing SSH config for #{machine.name}: #{e.message}")
+            @logger.debug("Backtrace: #{e.backtrace.join("\n")}")
+            
+            # Don't fail the vagrant provision process, just warn
+            machine.ui.warn("SSH config manager encountered an error during refresh: #{e.message}")
+          end
+        end
+      end
+    end
+  end
+end

data/lib/vagrant-ssh-config-manager/action/reload.rb

@@ -0,0 +1,106 @@
+module VagrantPlugins
+  module SshConfigManager
+    module Action
+      class Reload
+        def initialize(app, env)
+          @app = app
+          @env = env
+          @logger = Log4r::Logger.new("vagrant::plugins::ssh_config_manager::action::reload")
+        end
+
+        def call(env)
+          # Call the next middleware first
+          @app.call(env)
+
+          # Only proceed if the machine is running and SSH is ready
+          machine = env[:machine]
+          return unless machine && machine.state.id == :running
+
+          # Check if plugin is enabled
+          config = machine.config.sshconfigmanager
+          return unless config && config.enabled
+
+          # Handle SSH config update
+          handle_ssh_config_update(machine, config)
+        end
+
+        private
+
+        def handle_ssh_config_update(machine, config)
+          begin
+            @logger.info("Updating SSH config entry for machine: #{machine.name}")
+
+            # Lazy load required classes with error handling
+            begin
+              require 'vagrant-ssh-config-manager/ssh_info_extractor'
+              require 'vagrant-ssh-config-manager/file_manager'
+              require 'vagrant-ssh-config-manager/include_manager'
+            rescue LoadError => e
+              @logger.error("Failed to load required classes: #{e.message}")
+              machine.ui.warn("SSH config manager: Failed to load required components, skipping SSH config update")
+              return
+            end
+
+            # Extract SSH information
+            extractor = SshInfoExtractor.new(machine)
+            
+            # Check if machine supports SSH
+            unless extractor.ssh_capable?
+              @logger.debug("Machine #{machine.name} does not support SSH, skipping")
+              machine.ui.info("Machine #{machine.name} does not support SSH, skipping SSH config update")
+              return
+            end
+
+            # Create file manager and include manager
+            file_manager = FileManager.new(config)
+            include_manager = IncludeManager.new(config)
+
+            # Check if file exists and compare content
+            if file_manager.ssh_config_file_exists?(machine)
+              # Update SSH config file (always regenerate for simplicity)
+              @logger.info("SSH config file exists, updating for #{machine.name}")
+              if file_manager.write_ssh_config_file(machine)
+                host_name = file_manager.send(:generate_host_name, machine)
+                machine.ui.info("SSH config file updated for machine '#{machine.name}' (#{host_name})")
+                @logger.info("SSH config file updated due to reload")
+                
+                # Ensure Include directive is managed
+                include_manager.manage_include_directive
+              else
+                machine.ui.warn("Failed to update SSH config file for machine: #{machine.name}")
+                @logger.warn("Failed to update SSH config file for #{machine.name}")
+              end
+            else
+              # Add new SSH config file (machine might have been added during reload)
+              @logger.info("No existing SSH config file found, creating new file for #{machine.name}")
+              if file_manager.write_ssh_config_file(machine)
+                host_name = file_manager.send(:generate_host_name, machine)
+                machine.ui.info("SSH config file created for machine '#{machine.name}' as '#{host_name}'")
+                @logger.info("Successfully created new SSH config file for #{machine.name}")
+                
+                # Manage Include directive after file creation
+                include_manager.manage_include_directive
+              else
+                machine.ui.warn("Failed to create SSH config file for machine: #{machine.name}")
+                @logger.warn("Failed to create SSH config file for #{machine.name}")
+              end
+            end
+
+          rescue Errno::EACCES => e
+            @logger.error("Permission denied accessing SSH config for #{machine.name}: #{e.message}")
+            machine.ui.warn("SSH config manager: Permission denied. Check file permissions.")
+          rescue Errno::EIO => e
+            @logger.error("I/O error for #{machine.name}: #{e.message}")
+            machine.ui.warn("SSH config manager: I/O error accessing SSH config files.")
+          rescue => e
+            @logger.error("Error updating SSH config for #{machine.name}: #{e.message}")
+            @logger.debug("Backtrace: #{e.backtrace.join("\n")}")
+            
+            # Don't fail the vagrant reload process, just warn
+            machine.ui.warn("SSH config manager encountered an error: #{e.message}")
+          end
+        end
+      end
+    end
+  end
+end