vagrant-ssh-config-manager 0.8.3 → 1.0.0.alpha

data/lib/vagrant_ssh_config_manager/action/up.rb

@@ -0,0 +1,98 @@
+# frozen_string_literal: true
+
+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&.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 StandardError => 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)
+          @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 StandardError => 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

data/lib/{vagrant-ssh-config-manager → vagrant_ssh_config_manager}/config.rb

@@ -1,26 +1,26 @@
+# frozen_string_literal: true
+
 require 'fileutils'
 require 'vagrant'
 
 module VagrantPlugins
   module SshConfigManager
-    class Config < Vagrant.plugin("2", :config)
+    # Configuration for SSH Config Manager
+    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
+      attr_accessor :manage_includes, :auto_create_dir, :cleanup_empty_dir, :update_on_reload, :refresh_on_provision,
+                    :keep_config_on_halt, :project_isolation
 
       # 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
 
+      # Set initial state, call parent constructor
       def initialize
+        super
         @enabled = Vagrant::Plugin::V2::Config::UNSET_VALUE
         @ssh_config_dir = Vagrant::Plugin::V2::Config::UNSET_VALUE
         @manage_includes = Vagrant::Plugin::V2::Config::UNSET_VALUE
@@ -36,7 +36,9 @@ module VagrantPlugins
       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
+        if @ssh_config_dir == Vagrant::Plugin::V2::Config::UNSET_VALUE
+          @ssh_config_dir = File.expand_path('~/.ssh/config.d/vagrant')
+        end
         @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
@@ -48,48 +50,44 @@ module VagrantPlugins
 
         # 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)
+      def validate(_machine)
         errors = _detected_errors
 
         # Validate enabled flag
-        unless [true, false].include?(@enabled)
-          errors << "sshconfigmanager.enabled must be true or false"
-        end
+        errors << 'sshconfigmanager.enabled must be true or false' unless [true, false].include?(@enabled)
 
         # 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
+          if @ssh_config_dir.is_a?(String)
             # Validate directory path format
             expanded_path = File.expand_path(@ssh_config_dir)
-            if expanded_path.include?("..") || expanded_path.include?("//")
+            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
+            if File.directory?(@ssh_config_dir)
               # 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
+            elsif @auto_create_dir
+              begin
+                # Try to create the directory to validate the path
+                FileUtils.mkdir_p(@ssh_config_dir, mode: 0o700)
+              rescue StandardError => 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
+            errors << 'sshconfigmanager.ssh_config_dir must be a string path'
           end
         end
 
@@ -106,13 +104,11 @@ module VagrantPlugins
         }
 
         boolean_options.each do |option_name, value|
-          unless [true, false].include?(value)
-            errors << "sshconfigmanager.#{option_name} must be true or false"
-          end
+          errors << "sshconfigmanager.#{option_name} must be true or false" unless [true, false].include?(value)
         end
 
         # Return validation results
-        { "SSH Config Manager" => errors }
+        { 'SSH Config Manager' => errors }
       end
 
       # Get configuration summary for debugging
@@ -156,16 +152,16 @@ module VagrantPlugins
         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.enabled = other.enabled == UNSET_VALUE ? @enabled : other.enabled
+        result.ssh_config_dir = other.ssh_config_dir == UNSET_VALUE ? @ssh_config_dir : other.ssh_config_dir
+        result.manage_includes = other.manage_includes == UNSET_VALUE ? @manage_includes : other.manage_includes
+        result.auto_create_dir = other.auto_create_dir == UNSET_VALUE ? @auto_create_dir : other.auto_create_dir
+        result.cleanup_empty_dir = other.cleanup_empty_dir == UNSET_VALUE ? @cleanup_empty_dir : other.cleanup_empty_dir
+        result.auto_remove_on_destroy = other.auto_remove_on_destroy == UNSET_VALUE ? @auto_remove_on_destroy : other.auto_remove_on_destroy
+        result.update_on_reload = other.update_on_reload == UNSET_VALUE ? @update_on_reload : other.update_on_reload
+        result.refresh_on_provision = other.refresh_on_provision == UNSET_VALUE ? @refresh_on_provision : other.refresh_on_provision
+        result.keep_config_on_halt = other.keep_config_on_halt == UNSET_VALUE ? @keep_config_on_halt : other.keep_config_on_halt
+        result.project_isolation = other.project_isolation == UNSET_VALUE ? @project_isolation : other.project_isolation
 
         result
       end
@@ -176,19 +172,19 @@ module VagrantPlugins
         return true if File.directory?(@ssh_config_dir)
 
         begin
-          FileUtils.mkdir_p(@ssh_config_dir, mode: 0700)
+          FileUtils.mkdir_p(@ssh_config_dir, mode: 0o700)
           true
-        rescue => e
+        rescue StandardError
           false
         end
       end
 
-      # Get the appropriate manager instance 
-      def get_ssh_manager_instance(machine)
-        # Use separate file approach with FileManager
+      # Retrieve the SSH config manager for a given machine
+      def ssh_manager_instance(_machine)
         require_relative 'file_manager'
         FileManager.new(self)
       end
+      alias get_ssh_manager_instance ssh_manager_instance
     end
   end
 end

data/lib/{vagrant-ssh-config-manager → vagrant_ssh_config_manager}/file_locker.rb

@@ -1,8 +1,11 @@
+# frozen_string_literal: true
+
 require 'fcntl'
 require 'timeout'
 
 module VagrantPlugins
   module SshConfigManager
+    # Handles file locking for SSH config files to prevent concurrent conflicts
     class FileLocker
       # Default timeout for acquiring locks (in seconds)
       DEFAULT_TIMEOUT = 30
@@ -14,29 +17,25 @@ module VagrantPlugins
 
       def initialize(file_path, logger = nil)
         @file_path = file_path
-        @logger = logger || Log4r::Logger.new("vagrant::plugins::ssh_config_manager::file_locker")
+        @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
+      def with_exclusive_lock(timeout: DEFAULT_TIMEOUT, &block)
+        with_lock(LOCK_EXCLUSIVE, timeout: timeout, &block)
       end
 
       # Acquire a shared lock on the file
-      def with_shared_lock(timeout: DEFAULT_TIMEOUT)
-        with_lock(LOCK_SHARED, timeout: timeout) do
-          yield
-        end
+      def with_shared_lock(timeout: DEFAULT_TIMEOUT, &block)
+        with_lock(LOCK_SHARED, timeout: timeout, &block)
       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
@@ -45,7 +44,7 @@ module VagrantPlugins
           end
         rescue Errno::EAGAIN, Errno::EACCES
           true # File is locked
-        rescue => e
+        rescue StandardError => e
           @logger.debug("Error checking lock status: #{e.message}")
           false
         end
@@ -55,7 +54,7 @@ module VagrantPlugins
 
       def with_lock(lock_type, timeout: DEFAULT_TIMEOUT)
         acquire_lock(lock_type, timeout: timeout)
-        
+
         begin
           yield
         ensure
@@ -65,34 +64,33 @@ module VagrantPlugins
 
       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 = File.open(@file_path, File::RDWR | File::CREAT, 0o600)
           @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
+        raise LockTimeoutError, "Timeout waiting for lock on #{@file_path} (waited #{timeout}s)"
+      rescue StandardError => e
         cleanup_lock_file
         @logger.error("Failed to acquire lock on #{@file_path}: #{e.message}")
-        raise LockAcquisitionError.new("Could not acquire lock: #{e.message}")
+        raise LockAcquisitionError, "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
+        rescue StandardError => e
           @logger.warn("Error releasing lock: #{e.message}")
         ensure
           cleanup_lock_file
@@ -100,34 +98,34 @@ module VagrantPlugins
       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
+        return unless @lock_file
+
+        begin
+          @lock_file.close unless @lock_file.closed?
+        rescue StandardError => e
+          @logger.debug("Error closing lock file: #{e.message}")
+        ensure
+          @lock_file = nil
+          @locked = false
         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
+        return if File.directory?(dir)
+
+        FileUtils.mkdir_p(dir, mode: 0o700)
+        @logger.debug("Created directory: #{dir}")
       end
 
       def lock_type_name(lock_type)
         case lock_type
         when LOCK_SHARED
-          "shared"
+          'shared'
         when LOCK_EXCLUSIVE
-          "exclusive"
+          'exclusive'
         else
-          "unknown"
+          'unknown'
         end
       end
     end