vagrant-startcloud 0.1.2 → 0.1.3

data/lib/vagrant-startcloud/action/configure_shared_folders.rb

@@ -4,20 +4,19 @@ module VagrantPlugins
   module StartCloud
     module Action
       class ConfigureSharedFolders
-        def initialize(app, _env)
+        def initialize(app, env)
           @app = app
+          @env = env
+          @machine = env[:machine]
         end
 
         def call(env)
-          machine = env[:machine]
-          config = machine.config.startcloud
+          config = @machine.config.startcloud
+          folders = config.folders
 
-          if config.folders&.any?
-            env[:ui].info('Configuring shared folders...')
-
-            config.folders.each do |folder|
-              configure_folder(machine, folder)
-            end
+          if folders && !folders.empty?
+            @machine.ui.info I18n.t('vagrant_startcloud.configuring.folders')
+            configure_folders(folders)
           end
 
           @app.call(env)
@@ -25,45 +24,63 @@ module VagrantPlugins
 
         private
 
-        def configure_folder(machine, folder)
-          mount_opts = folder['type'] == 'virtualbox' ? ['actimeo=1'] : []
+        def configure_folders(folders)
+          folders.each do |folder|
+            next if folder['disabled']
+
+            options = build_folder_options(folder)
 
-          machine.config.vm.synced_folder(
-            folder['map'],
-            folder['to'],
+            begin
+              @machine.config.vm.synced_folder(
+                folder['map'],
+                folder['to'],
+                **options
+              )
+            rescue StandardError => e
+              @machine.ui.error I18n.t('vagrant_startcloud.errors.folder_error',
+                                       error: e.message)
+            end
+          end
+        end
+
+        def build_folder_options(folder)
+          options = {
             type: folder['type'],
-            owner: folder['owner'] || machine.config.startcloud.settings['vagrant_user'],
-            group: folder['group'] || machine.config.startcloud.settings['vagrant_user'],
-            mount_options: mount_opts,
-            automount: folder['automount'] || true,
-            scp__args: folder['args'],
-            rsync__args: folder['args'] || ['--verbose', '--archive', '-z', '--copy-links'],
-            rsync__chown: folder['chown'] || false,
-            create: folder['create'] || false,
-            rsync__rsync_ownership: folder['rsync_ownership'] || true,
-            disabled: folder['disabled'] || false
-          )
+            owner: folder['owner'],
+            group: folder['group'],
+            mount_options: get_mount_options(folder),
+            automount: true
+          }
 
-          # Configure syncback if enabled and scp-sync plugin is available
-          return unless folder['syncback'] && Vagrant.has_plugin?('vagrant-scp-sync')
+          # Add type-specific options
+          case folder['type']
+          when 'rsync'
+            options.merge!(
+              rsync__args: folder['args'] || ['--verbose', '--archive', '-z', '--copy-links'],
+              rsync__chown: folder['chown'] || false,
+              rsync__rsync_ownership: folder['rsync_ownership'] || true
+            )
+          when 'nfs'
+            options[:mount_options] = ['actimeo=1'] if options[:mount_options].empty?
+          end
 
-          configure_syncback(machine, folder)
+          # Remove nil values
+          options.compact
         end
 
-        def configure_syncback(machine, folder)
-          settings = machine.config.startcloud.settings
-          prefix = "==> #{settings['server_id']}--#{settings['hostname']}.#{settings['domain']}:"
+        def get_mount_options(folder)
+          mount_opts = []
 
-          machine.config.trigger.after :rsync, type: :command do |trigger|
-            trigger.info = 'Using SCP to sync from Guest to Host'
-            trigger.ruby do |_env, _machine|
-              guest_path = folder['to']
-              host_path = folder['map'].split(%r{(?<=/)[^/]*$}).last
-              transfer_cmd = "vagrant scp :#{guest_path} #{host_path}"
-              puts "#{prefix} #{transfer_cmd}"
-              system(transfer_cmd)
-            end
+          # Add type-specific mount options
+          case folder['type']
+          when 'nfs'
+            mount_opts << 'actimeo=1'
           end
+
+          # Add custom mount options if specified
+          mount_opts.concat(Array(folder['mount_options'])) if folder['mount_options']
+
+          mount_opts
         end
       end
     end

data/lib/vagrant-startcloud/action/is_created.rb

@@ -6,26 +6,14 @@ module VagrantPlugins
       class IsCreated
         def initialize(app, _env)
           @app = app
-          @logger = Log4r::Logger.new('vagrant_startcloud::action::is_created')
         end
 
         def call(env)
-          machine = env[:machine]
-          state_id = machine.state.id
-
-          @logger.debug("Checking if machine '#{machine.name}' is created (state: #{state_id})")
-
-          # Consider the machine created if it's in any state other than :not_created
-          env[:result] = state_id != :not_created
-
-          @logger.info("Machine '#{machine.name}' is #{env[:result] ? '' : 'not '}created")
+          # Set the result to be true if the machine is created
+          env[:result] = env[:machine].state.id != :not_created
 
           # Call the next middleware
           @app.call(env)
-        rescue StandardError => e
-          @logger.error("Error checking machine state: #{e.message}")
-          @logger.error(e.backtrace.join("\n"))
-          raise Errors::VMConfigurationError, error: e.message
         end
       end
     end

data/lib/vagrant-startcloud/action/is_virtualbox.rb

@@ -6,26 +6,15 @@ module VagrantPlugins
       class IsVirtualBox
         def initialize(app, _env)
           @app = app
-          @logger = Log4r::Logger.new('vagrant_startcloud::action::is_virtualbox')
         end
 
         def call(env)
-          machine = env[:machine]
-          provider_name = machine.provider_name
-
-          @logger.debug("Checking if machine '#{machine.name}' uses VirtualBox provider (current: #{provider_name})")
-
-          # Check if the provider is VirtualBox
-          env[:result] = provider_name == :virtualbox
-
-          @logger.info("Machine '#{machine.name}' is #{env[:result] ? '' : 'not '}using VirtualBox provider")
+          # Set the result to be true if the provider is VirtualBox
+          provider = env[:machine].provider_name
+          env[:result] = provider == :virtualbox
 
           # Call the next middleware
           @app.call(env)
-        rescue StandardError => e
-          @logger.error("Error checking provider: #{e.message}")
-          @logger.error(e.backtrace.join("\n"))
-          raise Errors::ProviderConfigurationError, error: e.message
         end
       end
     end

data/lib/vagrant-startcloud/action.rb

@@ -7,61 +7,114 @@ module VagrantPlugins
     module Action
       include Vagrant::Action::Builtin
 
-      def self.configure_machine
-        Vagrant::Action::Builder.new.tap do |b|
-          b.use ConfigValidate
-          b.use Call, IsCreated do |env, b2|
-            unless env[:result]
-              b2.use HandleBox
-              b2.use Import
+      class << self
+        def configure_machine
+          @configure_machine ||= Vagrant::Action::Builder.new.tap do |b|
+            b.use ConfigValidate
+            b.use Call, IsCreated do |env, b2|
+              unless env[:result]
+                b2.use HandleBox
+                b2.use Import
+              end
+            end
+          end
+        end
+
+        def configure_networks
+          @configure_networks ||= Vagrant::Action::Builder.new.tap do |b|
+            b.use Call, IsVirtualBox do |env, b2|
+              if env[:result]
+                b2.use ConfigureNetworks, provider: :virtualbox
+              else
+                b2.use ConfigureNetworks, provider: :zones
+              end
             end
+          end
+        end
 
-            b2.use Call, IsVirtualBox do |env2, b3|
-              if env2[:result]
-                b3.use ConfigureNetworks, provider: :virtualbox
+        def configure_providers
+          @configure_providers ||= Vagrant::Action::Builder.new.tap do |b|
+            b.use Call, IsVirtualBox do |env, b2|
+              if env[:result]
+                b2.use ConfigureProviders, provider: :virtualbox
               else
-                b3.use ConfigureNetworks, provider: :zone
+                b2.use ConfigureProviders, provider: :zones
               end
             end
+          end
+        end
 
-            b2.use Provision
+        def configure_shared_folders
+          @configure_shared_folders ||= Vagrant::Action::Builder.new.tap do |b|
+            b.use ConfigureSharedFolders
           end
         end
-      end
 
-      def self.action_halt
-        Vagrant::Action::Builder.new.tap do |b|
-          b.use ConfigValidate
-          b.use Call, IsCreated do |env, b2|
-            if env[:result]
-              b2.use Call, IsVirtualBox do |env2, b3|
-                if env2[:result]
-                  b3.use VagrantPlugins::ProviderVirtualBox::Action::GracefulHalt
-                else
-                  b3.use VagrantPlugins::ProviderZone::Action::GracefulHalt
+        def action_up
+          Vagrant::Action::Builder.new.tap do |b|
+            b.use configure_machine
+            b.use configure_providers
+            b.use Call, IsVirtualBox do |env, b2|
+              if env[:result]
+                b2.use ConfigureDisks, provider: :virtualbox
+              else
+                b2.use ConfigureDisks, provider: :zones
+              end
+            end
+            b.use configure_networks
+            b.use configure_shared_folders
+          end
+        end
+
+        def action_reload
+          action_up
+        end
+
+        def action_halt
+          Vagrant::Action::Builder.new.tap do |b|
+            b.use ConfigValidate
+            b.use Call, IsCreated do |env, b2|
+              if env[:result]
+                b2.use Call, IsVirtualBox do |env2, b3|
+                  if env2[:result]
+                    b3.use VagrantPlugins::ProviderVirtualBox::Action::GracefulHalt
+                  else
+                    b3.use VagrantPlugins::ProviderZone::Action::GracefulHalt
+                  end
                 end
+                b2.use PowerOff
               end
-              b2.use PowerOff
             end
           end
         end
-      end
 
-      def self.action_destroy
-        Vagrant::Action::Builder.new.tap do |b|
-          b.use ConfigValidate
-          b.use Call, IsCreated do |env, b2|
-            if env[:result]
-              b2.use action_halt
-              b2.use Call, IsVirtualBox do |env2, b3|
-                if env2[:result]
-                  b3.use VagrantPlugins::ProviderVirtualBox::Action::Destroy
-                else
-                  b3.use VagrantPlugins::ProviderZone::Action::Destroy
+        def action_destroy
+          Vagrant::Action::Builder.new.tap do |b|
+            b.use ConfigValidate
+            b.use Call, IsCreated do |env, b2|
+              if env[:result]
+                b2.use action_halt
+                b2.use Call, IsVirtualBox do |env2, b3|
+                  if env2[:result]
+                    b3.use VagrantPlugins::ProviderVirtualBox::Action::Destroy
+                  else
+                    b3.use VagrantPlugins::ProviderZone::Action::Destroy
+                  end
                 end
+                b2.use CleanupNetworks
+                b2.use ProvisionerCleanup
               end
-              b2.use CleanupNetworks
-              b2.use ProvisionerCleanup
+            end
+          end
+        end
+
+        def with_target_vms(machine_name = nil, **opts, &block)
+          env = opts.fetch(:env, Vagrant::Environment.new)
+          env.machine_names = [machine_name] if machine_name
+
+          env.batch(parallel: true) do |batch|
+            env.active_machines.each do |name, provider|
+              batch.action(env.machine(name, provider), :up, &block)
             end
           end
         end
@@ -70,20 +123,11 @@ module VagrantPlugins
       # Load middleware classes
       action_root = Pathname.new(File.expand_path('action', __dir__))
       autoload :ConfigureNetworks, action_root.join('configure_networks')
+      autoload :ConfigureProviders, action_root.join('configure_providers')
+      autoload :ConfigureSharedFolders, action_root.join('configure_shared_folders')
+      autoload :ConfigureDisks, action_root.join('configure_disks')
       autoload :IsCreated, action_root.join('is_created')
       autoload :IsVirtualBox, action_root.join('is_virtualbox')
-
-      # Helper methods
-      def self.with_target_vms(machine_name = nil, **opts, &block)
-        env = opts.fetch(:env, Vagrant::Environment.new)
-        env.machine_names = [machine_name] if machine_name
-
-        env.batch(parallel: true) do |batch|
-          env.active_machines.each do |name, provider|
-            batch.action(env.machine(name, provider), :up, &block)
-          end
-        end
-      end
     end
   end
 end

data/lib/vagrant-startcloud/config.rb

@@ -26,17 +26,16 @@ module VagrantPlugins
       def validate(_machine)
         errors = _detected_errors
 
-        errors << I18n.t('vagrant_startcloud.config.config_not_found', path: @config_path) if @config_path && !File.exist?(@config_path)
+        errors << "Configuration file '#{@config_path}' does not exist" if @config_path && !File.exist?(@config_path)
 
         if @settings.empty?
-          errors << I18n.t('vagrant_startcloud.config.no_settings')
+          errors << 'No settings defined in configuration'
           return { 'StartCloud configuration' => errors }
         end
 
         required_settings = %w[hostname domain server_id box]
         missing_settings = required_settings - @settings.keys
-
-        errors << I18n.t('vagrant_startcloud.config.missing_required', fields: missing_settings.join(', ')) unless missing_settings.empty?
+        errors << "Missing required settings: #{missing_settings.join(', ')}" unless missing_settings.empty?
 
         { 'StartCloud configuration' => errors }
       end
@@ -44,21 +43,86 @@ module VagrantPlugins
       def load_config(machine)
         return unless @config_path && File.exist?(@config_path)
 
-        config = YAML.load_file(@config_path)
-        return unless config && config['hosts']
-
-        host = config['hosts'].first
-        @settings = host['settings'] || {}
-        @networks = host['networks'] || []
-        @disks = host['disks'] || {}
-        @provisioning = host['provisioning'] || {}
-        @folders = host['folders'] || []
-        @roles = host['roles'] || []
-        @vars = host['vars'] || {}
-        @plugins = host['plugins'] || {}
-        @zones = host['zones'] || {}
-      rescue StandardError => e
-        machine.ui.error(I18n.t('vagrant_startcloud.config.yaml_error', error: e.message))
+        begin
+          yaml_config = YAML.load_file(@config_path)
+          return unless yaml_config && yaml_config['hosts']
+
+          host = yaml_config['hosts'].first
+
+          # Load all configuration sections
+          @settings = host['settings'] || {}
+          @networks = host['networks'] || []
+          @disks = host['disks'] || {}
+          @provisioning = host['provisioning'] || {}
+          @folders = host['folders'] || []
+          @roles = host['roles'] || []
+          @vars = host['vars'] || {}
+          @plugins = host['plugins'] || {}
+          @zones = host['zones'] || {}
+
+          # Configure plugins if specified
+          configure_plugins(host['plugins']) if host['plugins']
+
+          # Configure provider-specific settings
+          configure_provider(machine, host) if @settings['provider_type']
+        rescue StandardError => e
+          raise Errors::YAMLParseError, _key: :yaml_error, error: e.message
+        end
+      end
+
+      private
+
+      def configure_provider(machine, host)
+        provider_type = @settings['provider_type'].to_sym
+
+        machine.vm.provider provider_type do |provider|
+          case provider_type
+          when :virtualbox
+            configure_virtualbox(provider, host)
+          when :zones
+            configure_zones(provider, host)
+          end
+        end
+      end
+
+      def configure_virtualbox(provider, host)
+        settings = host['settings']
+        memory = if settings['memory'].to_s =~ /gb|g/i
+                   1024 * settings['memory'].to_s.tr('^0-9', '').to_i
+                 else
+                   settings['memory'].to_s.tr('^0-9', '').to_i
+                 end
+
+        provider.name = "#{settings['server_id']}--#{settings['hostname']}.#{settings['domain']}"
+        provider.gui = settings['show_console']
+        provider.memory = memory if memory.positive?
+        provider.cpus = settings['vcpus']
+      end
+
+      def configure_zones(provider, host)
+        settings = host['settings']
+        zones = host['zones']
+
+        provider.hostname = "#{settings['hostname']}.#{settings['domain']}"
+        provider.brand = zones['brand']
+        provider.memory = settings['memory']
+        provider.cpus = settings['vcpus']
+      end
+
+      def configure_plugins(plugins)
+        return unless plugins
+
+        plugins['install']&.each do |plugin|
+          unless Vagrant.has_plugin?(plugin['name'])
+            system("vagrant plugin install #{plugin['name']}" + (plugin['version'] == 'latest' ? '' : " --plugin-version #{plugin['version']}"))
+          end
+        end
+
+        return unless plugins['remove']
+
+        plugins['remove'].each do |plugin|
+          system("vagrant plugin uninstall #{plugin['name']}") if Vagrant.has_plugin?(plugin['name'])
+        end
       end
     end
   end

data/lib/vagrant-startcloud/plugin.rb

@@ -27,27 +27,43 @@ module VagrantPlugins
         Provisioner
       end
 
-      # Register command
-      command(:startcloud) do
-        require_relative 'command'
-        [VagrantPlugins::StartCloud::Command, { primary: true }]
+      # Register action hooks
+      action_hook(:startcloud_up, :machine_action_up) do |hook|
+        require_relative 'action'
+        hook.after(Vagrant::Action::Builtin::Provision, Action.action_up)
       end
 
-      # Register action hooks
-      action_hook(:startcloud_configure, :machine_action_up) do |hook|
+      action_hook(:startcloud_reload, :machine_action_reload) do |hook|
         require_relative 'action'
-        hook.before(Vagrant::Action::Builtin::ConfigValidate, Action.configure_machine)
+        hook.after(Vagrant::Action::Builtin::Provision, Action.action_reload)
       end
 
-      # Register provider capabilities
-      provider_capability(:virtualbox, :configure_networks) do
-        require_relative 'action/configure_networks'
-        Action::ConfigureNetworks
+      action_hook(:startcloud_halt, :machine_action_halt) do |hook|
+        require_relative 'action'
+        hook.after(Vagrant::Action::Builtin::GracefulHalt, Action.action_halt)
+      end
+
+      action_hook(:startcloud_destroy, :machine_action_destroy) do |hook|
+        require_relative 'action'
+        hook.after(Vagrant::Action::Builtin::DestroyConfirm, Action.action_destroy)
       end
 
-      provider_capability(:zones, :configure_networks) do
-        require_relative 'action/configure_networks'
-        Action::ConfigureNetworks
+      # Register provider capabilities
+      %i[virtualbox zones].each do |provider|
+        provider_capability(provider, :configure_networks) do
+          require_relative 'action/configure_networks'
+          Action::ConfigureNetworks
+        end
+
+        provider_capability(provider, :configure_disks) do
+          require_relative 'action/configure_disks'
+          Action::ConfigureDisks
+        end
+
+        provider_capability(provider, :configure_provider) do
+          require_relative 'action/configure_providers'
+          Action::ConfigureProviders
+        end
       end
 
       # Plugin registration
@@ -73,7 +89,6 @@ module VagrantPlugins
             c = Vagrant::Plugin::V2::Components.new
             c.configs[:top].register(:startcloud) { Config }
             c.configs[:provisioner].register(:startcloud) { Config }
-            c.commands.register(:startcloud) { [Command, { primary: true }] }
             c.provisioners.register(:startcloud) { Provisioner }
             c
           end

data/lib/vagrant-startcloud/version.rb

@@ -2,6 +2,6 @@
 
 module VagrantPlugins
   module StartCloud
-    VERSION = '0.1.2'
+    VERSION = '0.1.3'
   end
 end

data/lib/vagrant-startcloud.rb

@@ -3,6 +3,59 @@
 require 'pathname'
 require 'i18n'
 require 'vagrant'
+require 'yaml'
+
+# Top-level module for the plugin
+module StartCloud
+  def self.configure(config, settings_file = 'Hosts.yml')
+    unless File.exist?(settings_file)
+      raise Vagrant::Errors::VagrantError.new(
+        error_message: "StartCloud configuration file not found: #{settings_file}"
+      )
+    end
+
+    yaml_config = YAML.load_file(settings_file)
+    return unless yaml_config && yaml_config['hosts']
+
+    # Configure each VM defined in hosts
+    yaml_config['hosts'].each do |host|
+      settings = host['settings']
+      hostname = "#{settings['hostname']}.#{settings['domain']}"
+      vm_name = "#{settings['server_id']}--#{hostname}"
+
+      config.vm.define vm_name do |machine|
+        # Configure the StartCloud plugin first
+        machine.startcloud.config_path = settings_file
+        machine.startcloud.settings = settings
+        machine.startcloud.networks = host['networks'] || []
+        machine.startcloud.disks = host['disks'] || {}
+        machine.startcloud.folders = host['folders'] || []
+        machine.startcloud.roles = host['roles'] || []
+        machine.startcloud.vars = host['vars'] || {}
+        machine.startcloud.plugins = host['plugins'] || {}
+        machine.startcloud.zones = host['zones'] || {}
+
+        # Set basic VM settings
+        machine.vm.box = settings['box']
+        machine.vm.hostname = hostname
+        machine.vm.boot_timeout = settings['setup_wait'] if settings['setup_wait']
+
+        # Configure SSH settings
+        if settings['vagrant_user']
+          machine.ssh.username = settings['vagrant_user']
+          machine.ssh.private_key_path = settings['vagrant_user_private_key_path'] if settings['vagrant_user_private_key_path']
+        end
+        machine.ssh.insert_key = false
+        machine.ssh.forward_agent = true
+
+        # Set provider
+        machine.vm.provider settings['provider_type'].to_sym do |provider|
+          provider.name = vm_name if provider.respond_to?(:name=)
+        end
+      end
+    end
+  end
+end
 
 module VagrantPlugins
   module StartCloud
@@ -12,7 +65,6 @@ module VagrantPlugins
     require lib_path.join('version')
     require lib_path.join('errors')
     require lib_path.join('config')
-    require lib_path.join('command')
     require lib_path.join('provisioner')
     require lib_path.join('config_builder')
     require lib_path.join('action')

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: vagrant-startcloud
 version: !ruby/object:Gem::Version
-  version: 0.1.2
+  version: 0.1.3
 platform: ruby
 authors:
 - Mark Gilbert
@@ -201,6 +201,7 @@ files:
 - README.md
 - lib/vagrant-startcloud.rb
 - lib/vagrant-startcloud/action.rb
+- lib/vagrant-startcloud/action/configure_disks.rb
 - lib/vagrant-startcloud/action/configure_networks.rb
 - lib/vagrant-startcloud/action/configure_providers.rb
 - lib/vagrant-startcloud/action/configure_provisioners.rb