vagrant-ssh-config-manager 0.8.2

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

@@ -0,0 +1,99 @@
+module VagrantPlugins
+  module SshConfigManager
+    module Action
+      class Up
+        def initialize(app, env)
+          @app = app
+          @env = env
+          @logger = Log4r::Logger.new("vagrant::plugins::ssh_config_manager::action::up")
+        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
+          return unless machine.state.id == :running
+
+          # Check if plugin is enabled
+          config = machine.config.sshconfigmanager
+          return unless config && config.enabled
+
+          @logger.info("SSH Config Manager: Creating SSH config file for machine: #{machine.name}")
+
+          # Handle SSH config file creation
+          handle_ssh_config_creation(machine, config)
+        rescue => e
+          @logger.error("SSH Config Manager: Error in Up action: #{e.message}")
+          @logger.debug("Backtrace: #{e.backtrace.join("\n")}")
+        end
+
+        private
+
+        def handle_ssh_config_creation(machine, config)
+          begin
+            @logger.info("Creating SSH config file 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 creation")
+              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)
+
+            # Write SSH config file
+            @logger.info("Attempting to create SSH config 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}'")
+              machine.ui.info("You can now connect with: ssh #{host_name}")
+              @logger.info("Successfully created 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
+
+          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::ENOSPC => e
+            @logger.error("No space left on device for #{machine.name}: #{e.message}")
+            machine.ui.warn("SSH config manager: No space left on device.")
+          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 creating SSH config for #{machine.name}: #{e.message}")
+            @logger.debug("Backtrace: #{e.backtrace.join("\n")}")
+            
+            # Don't fail the vagrant up process, just warn
+            machine.ui.warn("SSH config manager encountered an error: #{e.message}")
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,194 @@
+require 'fileutils'
+require 'vagrant'
+
+module VagrantPlugins
+  module SshConfigManager
+    class Config < Vagrant.plugin("2", :config)
+      # Plugin enabled/disabled flag
+      attr_accessor :enabled
+
+      # SSH config directory configuration
+      attr_accessor :ssh_config_dir
+      attr_accessor :manage_includes
+      attr_accessor :auto_create_dir
+      attr_accessor :cleanup_empty_dir
+
+      # Additional configuration options
+      attr_accessor :auto_remove_on_destroy
+      attr_accessor :update_on_reload
+      attr_accessor :refresh_on_provision
+      attr_accessor :keep_config_on_halt
+      attr_accessor :project_isolation
+
+      def initialize
+        @enabled = Vagrant::Plugin::V2::Config::UNSET_VALUE
+        @ssh_config_dir = Vagrant::Plugin::V2::Config::UNSET_VALUE
+        @manage_includes = Vagrant::Plugin::V2::Config::UNSET_VALUE
+        @auto_create_dir = Vagrant::Plugin::V2::Config::UNSET_VALUE
+        @cleanup_empty_dir = Vagrant::Plugin::V2::Config::UNSET_VALUE
+        @auto_remove_on_destroy = Vagrant::Plugin::V2::Config::UNSET_VALUE
+        @update_on_reload = Vagrant::Plugin::V2::Config::UNSET_VALUE
+        @refresh_on_provision = Vagrant::Plugin::V2::Config::UNSET_VALUE
+        @keep_config_on_halt = Vagrant::Plugin::V2::Config::UNSET_VALUE
+        @project_isolation = Vagrant::Plugin::V2::Config::UNSET_VALUE
+      end
+
+      def finalize!
+        # Set default values for unset configuration options
+        @enabled = true if @enabled == Vagrant::Plugin::V2::Config::UNSET_VALUE
+        @ssh_config_dir = File.expand_path("~/.ssh/config.d/vagrant") if @ssh_config_dir == Vagrant::Plugin::V2::Config::UNSET_VALUE
+        @manage_includes = false if @manage_includes == Vagrant::Plugin::V2::Config::UNSET_VALUE
+        @auto_create_dir = true if @auto_create_dir == Vagrant::Plugin::V2::Config::UNSET_VALUE
+        @cleanup_empty_dir = true if @cleanup_empty_dir == Vagrant::Plugin::V2::Config::UNSET_VALUE
+        @auto_remove_on_destroy = true if @auto_remove_on_destroy == Vagrant::Plugin::V2::Config::UNSET_VALUE
+        @update_on_reload = true if @update_on_reload == Vagrant::Plugin::V2::Config::UNSET_VALUE
+        @refresh_on_provision = true if @refresh_on_provision == Vagrant::Plugin::V2::Config::UNSET_VALUE
+        @keep_config_on_halt = true if @keep_config_on_halt == Vagrant::Plugin::V2::Config::UNSET_VALUE
+        @project_isolation = true if @project_isolation == Vagrant::Plugin::V2::Config::UNSET_VALUE
+
+        # Expand and validate file paths
+        @ssh_config_dir = File.expand_path(@ssh_config_dir) if @ssh_config_dir.is_a?(String)
+        
+        # Ensure SSH config directory exists if auto_create_dir is enabled
+        ensure_ssh_config_directory if @auto_create_dir && @ssh_config_dir
+      end
+
+      def validate(machine)
+        errors = _detected_errors
+
+        # Validate enabled flag
+        unless [true, false].include?(@enabled)
+          errors << "sshconfigmanager.enabled must be true or false"
+        end
+
+        # Validate SSH config directory
+        if @ssh_config_dir
+          unless @ssh_config_dir.is_a?(String)
+            errors << "sshconfigmanager.ssh_config_dir must be a string path"
+          else
+            # Validate directory path format
+            expanded_path = File.expand_path(@ssh_config_dir)
+            if expanded_path.include?("..") || expanded_path.include?("//")
+              errors << "sshconfigmanager.ssh_config_dir contains invalid path components: #{@ssh_config_dir}"
+            end
+
+            # Check if the directory exists or can be created
+            unless File.directory?(@ssh_config_dir)
+              if @auto_create_dir
+                begin
+                  # Try to create the directory to validate the path
+                  FileUtils.mkdir_p(@ssh_config_dir, mode: 0700)
+                rescue => e
+                  errors << "sshconfigmanager.ssh_config_dir cannot be created: #{e.message}"
+                end
+              else
+                errors << "sshconfigmanager.ssh_config_dir does not exist and auto_create_dir is disabled: #{@ssh_config_dir}"
+              end
+            else
+              # Check directory permissions
+              unless File.readable?(@ssh_config_dir) && File.writable?(@ssh_config_dir)
+                errors << "sshconfigmanager.ssh_config_dir is not readable/writable: #{@ssh_config_dir}"
+              end
+            end
+          end
+        end
+
+        # Validate boolean options
+        boolean_options = {
+          'auto_remove_on_destroy' => @auto_remove_on_destroy,
+          'update_on_reload' => @update_on_reload,
+          'refresh_on_provision' => @refresh_on_provision,
+          'keep_config_on_halt' => @keep_config_on_halt,
+          'project_isolation' => @project_isolation,
+          'manage_includes' => @manage_includes,
+          'auto_create_dir' => @auto_create_dir,
+          'cleanup_empty_dir' => @cleanup_empty_dir
+        }
+
+        boolean_options.each do |option_name, value|
+          unless [true, false].include?(value)
+            errors << "sshconfigmanager.#{option_name} must be true or false"
+          end
+        end
+
+        # Return validation results
+        { "SSH Config Manager" => errors }
+      end
+
+      # Get configuration summary for debugging
+      def to_hash
+        {
+          enabled: @enabled,
+          ssh_config_dir: @ssh_config_dir,
+          manage_includes: @manage_includes,
+          auto_create_dir: @auto_create_dir,
+          cleanup_empty_dir: @cleanup_empty_dir,
+          auto_remove_on_destroy: @auto_remove_on_destroy,
+          update_on_reload: @update_on_reload,
+          refresh_on_provision: @refresh_on_provision,
+          keep_config_on_halt: @keep_config_on_halt,
+          project_isolation: @project_isolation
+        }
+      end
+
+      # Check if the plugin should operate for a given action
+      def enabled_for_action?(action_name)
+        return false unless @enabled
+
+        case action_name.to_sym
+        when :up, :resume
+          true
+        when :destroy
+          @auto_remove_on_destroy
+        when :reload
+          @update_on_reload
+        when :provision
+          @refresh_on_provision
+        when :halt, :suspend
+          @keep_config_on_halt
+        else
+          false
+        end
+      end
+
+      # Merge configuration from another config object (for inheritance)
+      def merge(other)
+        result = self.class.new
+
+        # Merge each attribute, preferring the other config's values if set
+        result.enabled = other.enabled != UNSET_VALUE ? other.enabled : @enabled
+        result.ssh_config_dir = other.ssh_config_dir != UNSET_VALUE ? other.ssh_config_dir : @ssh_config_dir
+        result.manage_includes = other.manage_includes != UNSET_VALUE ? other.manage_includes : @manage_includes
+        result.auto_create_dir = other.auto_create_dir != UNSET_VALUE ? other.auto_create_dir : @auto_create_dir
+        result.cleanup_empty_dir = other.cleanup_empty_dir != UNSET_VALUE ? other.cleanup_empty_dir : @cleanup_empty_dir
+        result.auto_remove_on_destroy = other.auto_remove_on_destroy != UNSET_VALUE ? other.auto_remove_on_destroy : @auto_remove_on_destroy
+        result.update_on_reload = other.update_on_reload != UNSET_VALUE ? other.update_on_reload : @update_on_reload
+        result.refresh_on_provision = other.refresh_on_provision != UNSET_VALUE ? other.refresh_on_provision : @refresh_on_provision
+        result.keep_config_on_halt = other.keep_config_on_halt != UNSET_VALUE ? other.keep_config_on_halt : @keep_config_on_halt
+        result.project_isolation = other.project_isolation != UNSET_VALUE ? other.project_isolation : @project_isolation
+
+        result
+      end
+
+      # Create SSH config directory with proper permissions
+      def ensure_ssh_config_directory
+        return false unless @auto_create_dir
+        return true if File.directory?(@ssh_config_dir)
+
+        begin
+          FileUtils.mkdir_p(@ssh_config_dir, mode: 0700)
+          true
+        rescue => e
+          false
+        end
+      end
+
+      # Get the appropriate manager instance 
+      def get_ssh_manager_instance(machine)
+        # Use separate file approach with FileManager
+        require_relative 'file_manager'
+        FileManager.new(self)
+      end
+    end
+  end
+end

data/lib/vagrant-ssh-config-manager/file_locker.rb

@@ -0,0 +1,140 @@
+require 'fcntl'
+require 'timeout'
+
+module VagrantPlugins
+  module SshConfigManager
+    class FileLocker
+      # Default timeout for acquiring locks (in seconds)
+      DEFAULT_TIMEOUT = 30
+
+      # Lock types
+      LOCK_SHARED = File::LOCK_SH
+      LOCK_EXCLUSIVE = File::LOCK_EX
+      LOCK_NON_BLOCKING = File::LOCK_NB
+
+      def initialize(file_path, logger = nil)
+        @file_path = file_path
+        @logger = logger || Log4r::Logger.new("vagrant::plugins::ssh_config_manager::file_locker")
+        @lock_file = nil
+        @locked = false
+      end
+
+      # Acquire an exclusive lock on the file
+      def with_exclusive_lock(timeout: DEFAULT_TIMEOUT)
+        with_lock(LOCK_EXCLUSIVE, timeout: timeout) do
+          yield
+        end
+      end
+
+      # Acquire a shared lock on the file
+      def with_shared_lock(timeout: DEFAULT_TIMEOUT)
+        with_lock(LOCK_SHARED, timeout: timeout) do
+          yield
+        end
+      end
+
+      # Check if file is currently locked by another process
+      def locked?
+        return false unless File.exist?(@file_path)
+        
+        begin
+          File.open(@file_path, 'r') do |file|
+            # Try to acquire a non-blocking exclusive lock
+            file.flock(LOCK_EXCLUSIVE | LOCK_NON_BLOCKING)
+            false # Not locked if we could acquire the lock
+          end
+        rescue Errno::EAGAIN, Errno::EACCES
+          true # File is locked
+        rescue => e
+          @logger.debug("Error checking lock status: #{e.message}")
+          false
+        end
+      end
+
+      private
+
+      def with_lock(lock_type, timeout: DEFAULT_TIMEOUT)
+        acquire_lock(lock_type, timeout: timeout)
+        
+        begin
+          yield
+        ensure
+          release_lock
+        end
+      end
+
+      def acquire_lock(lock_type, timeout: DEFAULT_TIMEOUT)
+        ensure_directory_exists
+        
+        @logger.debug("Acquiring #{lock_type_name(lock_type)} lock on #{@file_path}")
+        
+        # Use timeout to prevent infinite waiting
+        Timeout.timeout(timeout) do
+          @lock_file = File.open(@file_path, File::RDWR | File::CREAT, 0600)
+          @lock_file.flock(lock_type)
+          @locked = true
+          @logger.debug("Successfully acquired lock on #{@file_path}")
+        end
+        
+      rescue Timeout::Error
+        cleanup_lock_file
+        raise LockTimeoutError.new("Timeout waiting for lock on #{@file_path} (waited #{timeout}s)")
+      rescue => e
+        cleanup_lock_file
+        @logger.error("Failed to acquire lock on #{@file_path}: #{e.message}")
+        raise LockAcquisitionError.new("Could not acquire lock: #{e.message}")
+      end
+
+      def release_lock
+        return unless @locked && @lock_file
+
+        @logger.debug("Releasing lock on #{@file_path}")
+        
+        begin
+          @lock_file.flock(File::LOCK_UN)
+        rescue => e
+          @logger.warn("Error releasing lock: #{e.message}")
+        ensure
+          cleanup_lock_file
+        end
+      end
+
+      def cleanup_lock_file
+        if @lock_file
+          begin
+            @lock_file.close unless @lock_file.closed?
+          rescue => e
+            @logger.debug("Error closing lock file: #{e.message}")
+          ensure
+            @lock_file = nil
+            @locked = false
+          end
+        end
+      end
+
+      def ensure_directory_exists
+        dir = File.dirname(@file_path)
+        unless File.directory?(dir)
+          FileUtils.mkdir_p(dir, mode: 0700)
+          @logger.debug("Created directory: #{dir}")
+        end
+      end
+
+      def lock_type_name(lock_type)
+        case lock_type
+        when LOCK_SHARED
+          "shared"
+        when LOCK_EXCLUSIVE
+          "exclusive"
+        else
+          "unknown"
+        end
+      end
+    end
+
+    # Custom exception classes
+    class LockError < StandardError; end
+    class LockTimeoutError < LockError; end
+    class LockAcquisitionError < LockError; end
+  end
+end

data/lib/vagrant-ssh-config-manager/file_manager.rb

@@ -0,0 +1,245 @@
+require 'fileutils'
+require 'digest'
+require 'tempfile'
+require 'log4r'
+
+module VagrantPlugins
+  module SshConfigManager
+    class FileManager
+      # Initialize FileManager with configuration
+      def initialize(config)
+        @config = config
+        @logger = Log4r::Logger.new("vagrant::plugins::sshconfigmanager::filemanager")
+      end
+
+      # Generate unique filename for VM SSH config
+      # Format: {project_hash}-{vm_name}.conf
+      def generate_filename(machine)
+        project_hash = generate_project_hash(machine.env.root_path.to_s)
+        vm_name = machine.name.to_s
+        "#{project_hash}-#{vm_name}.conf"
+      end
+
+      # Get full path for VM SSH config file
+      def get_file_path(machine)
+        filename = generate_filename(machine)
+        File.join(@config.ssh_config_dir, filename)
+      end
+
+      # Generate SSH config content for a VM
+      def generate_ssh_config_content(machine)
+        ssh_info = machine.ssh_info
+        return nil unless ssh_info
+
+        content = []
+        content << "# Managed by vagrant-ssh-config-manager plugin"
+        content << "# Project: #{File.basename(machine.env.root_path)}"
+        content << "# VM: #{machine.name}"
+        content << "# Generated: #{Time.now.strftime('%Y-%m-%d %H:%M:%S')}"
+        content << ""
+        
+        host_name = generate_host_name(machine)
+        content << "Host #{host_name}"
+        content << "  HostName #{ssh_info[:host]}"
+        content << "  Port #{ssh_info[:port]}"
+        content << "  User #{ssh_info[:username]}"
+        
+        if ssh_info[:private_key_path] && ssh_info[:private_key_path].first
+          content << "  IdentityFile #{ssh_info[:private_key_path].first}"
+          content << "  IdentitiesOnly yes"
+        end
+        
+        content << "  UserKnownHostsFile /dev/null"
+        content << "  StrictHostKeyChecking no"
+        content << "  PasswordAuthentication no"
+        content << "  LogLevel FATAL"
+        content << ""
+
+        content.join("\n")
+      end
+
+      # Write SSH config file for VM with atomic operation
+      def write_ssh_config_file(machine)
+        return false unless @config.enabled
+
+        file_path = get_file_path(machine)
+        content = generate_ssh_config_content(machine)
+        return false unless content
+
+        begin
+          # Ensure directory exists
+          FileUtils.mkdir_p(File.dirname(file_path), mode: 0700)
+          
+          # Use atomic write with temporary file
+          write_file_atomically(file_path, content)
+          
+          @logger.info("SSH config file created: #{file_path}")
+          true
+        rescue => e
+          @logger.error("Failed to write SSH config file #{file_path}: #{e.message}")
+          false
+        end
+      end
+
+      # Remove SSH config file for VM
+      def remove_ssh_config_file(machine)
+        file_path = get_file_path(machine)
+        
+        begin
+          if File.exist?(file_path)
+            File.delete(file_path)
+            @logger.info("SSH config file removed: #{file_path}")
+            
+            # Clean up empty directory if configured
+            cleanup_empty_directory if @config.cleanup_empty_dir
+            true
+          else
+            @logger.debug("SSH config file does not exist: #{file_path}")
+            false
+          end
+        rescue => e
+          @logger.error("Failed to remove SSH config file #{file_path}: #{e.message}")
+          false
+        end
+      end
+
+      # Check if SSH config file exists for VM
+      def ssh_config_file_exists?(machine)
+        File.exist?(get_file_path(machine))
+      end
+
+      # Validate SSH config file content
+      def validate_ssh_config_content(content)
+        return false if content.nil? || content.empty?
+        
+        # Basic validation - check for required SSH config elements
+        content.include?("Host ") && content.include?("HostName ") && content.include?("Port ")
+      end
+
+      # Detect and clean up orphaned SSH config files
+      def cleanup_orphaned_files
+        return unless Dir.exist?(@config.ssh_config_dir)
+
+        orphaned_files = []
+        config_files = Dir.glob(File.join(@config.ssh_config_dir, "*.conf"))
+
+        config_files.each do |file_path|
+          filename = File.basename(file_path, ".conf")
+          
+          # Parse filename to extract project hash and VM name
+          if filename.match(/^([a-f0-9]{8})-(.+)$/)
+            project_hash = $1
+            vm_name = $2
+            
+            # Check if this looks like an orphaned file
+            # (This is a basic heuristic - in practice, you might want more sophisticated detection)
+            file_age = Time.now - File.mtime(file_path)
+            
+            # Consider files older than 30 days as potentially orphaned
+            if file_age > (30 * 24 * 60 * 60) # 30 days in seconds
+              orphaned_files << {
+                path: file_path,
+                project_hash: project_hash,
+                vm_name: vm_name,
+                age_days: (file_age / (24 * 60 * 60)).round
+              }
+            end
+          end
+        end
+
+        # Log detected orphaned files
+        unless orphaned_files.empty?
+          @logger.info("Detected #{orphaned_files.length} potentially orphaned SSH config files")
+          orphaned_files.each do |file_info|
+            @logger.debug("Orphaned file: #{file_info[:path]} (#{file_info[:age_days]} days old)")
+          end
+        end
+
+        orphaned_files
+      end
+
+      # Remove orphaned SSH config files
+      def remove_orphaned_files
+        orphaned_files = cleanup_orphaned_files
+        removed_count = 0
+
+        orphaned_files.each do |file_info|
+          begin
+            File.delete(file_info[:path])
+            @logger.info("Removed orphaned SSH config file: #{file_info[:path]}")
+            removed_count += 1
+          rescue => e
+            @logger.error("Failed to remove orphaned file #{file_info[:path]}: #{e.message}")
+          end
+        end
+
+        # Clean up empty directory if configured
+        cleanup_empty_directory if @config.cleanup_empty_dir && removed_count > 0
+
+        removed_count
+      end
+
+      # Get all config files in the directory
+      def get_all_config_files
+        return [] unless Dir.exist?(@config.ssh_config_dir)
+        Dir.glob(File.join(@config.ssh_config_dir, "*.conf"))
+      end
+
+      private
+
+      # Generate unique project hash from root path
+      def generate_project_hash(root_path)
+        Digest::MD5.hexdigest(root_path)[0, 8]
+      end
+
+      # Generate SSH host name for machine
+      def generate_host_name(machine)
+        if @config.project_isolation
+          project_name = File.basename(machine.env.root_path)
+          "#{project_name}-#{machine.name}"
+        else
+          machine.name.to_s
+        end
+      end
+
+      # Write file atomically using temporary file and rename
+      def write_file_atomically(file_path, content)
+        temp_file = Tempfile.new(File.basename(file_path), File.dirname(file_path))
+        begin
+          temp_file.write(content)
+          temp_file.close
+          
+          # Set proper permissions before moving
+          File.chmod(0600, temp_file.path)
+          
+          # Atomic move
+          FileUtils.mv(temp_file.path, file_path)
+        ensure
+          temp_file.unlink if temp_file && File.exist?(temp_file.path)
+        end
+      end
+
+      # Clean up empty directory if no config files remain
+      def cleanup_empty_directory
+        return unless Dir.exist?(@config.ssh_config_dir)
+        
+        entries = Dir.entries(@config.ssh_config_dir) - %w[. ..]
+        if entries.empty?
+          begin
+            # Remove Include directive before removing directory
+            if @config.manage_includes
+              require_relative 'include_manager'
+              include_manager = IncludeManager.new(@config)
+              include_manager.remove_include_directive
+            end
+            
+            Dir.rmdir(@config.ssh_config_dir)
+            @logger.info("Removed empty SSH config directory: #{@config.ssh_config_dir}")
+          rescue => e
+            @logger.error("Failed to remove empty directory #{@config.ssh_config_dir}: #{e.message}")
+          end
+        end
+      end
+    end
+  end
+end