vagrant-startcloud 0.1.2

data/lib/vagrant-startcloud/action.rb

@@ -0,0 +1,89 @@
+# frozen_string_literal: true
+
+require 'vagrant/action/builder'
+
+module VagrantPlugins
+  module StartCloud
+    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
+            end
+
+            b2.use Call, IsVirtualBox do |env2, b3|
+              if env2[:result]
+                b3.use ConfigureNetworks, provider: :virtualbox
+              else
+                b3.use ConfigureNetworks, provider: :zone
+              end
+            end
+
+            b2.use Provision
+          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
+                end
+              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
+                end
+              end
+              b2.use CleanupNetworks
+              b2.use ProvisionerCleanup
+            end
+          end
+        end
+      end
+
+      # Load middleware classes
+      action_root = Pathname.new(File.expand_path('action', __dir__))
+      autoload :ConfigureNetworks, action_root.join('configure_networks')
+      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/command.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+require 'yaml'
+
+module VagrantPlugins
+  module StartCloud
+    class Command < Vagrant.plugin('2', :command)
+      def initialize(argv, env)
+        super
+        @env = env
+      end
+
+      def execute
+        config_file = 'Hosts.yml'
+
+        unless File.exist?(config_file)
+          @env.ui.error(I18n.t('vagrant_startcloud.config.config_not_found', path: config_file))
+          return 1
+        end
+
+        begin
+          config = YAML.load_file(config_file)
+          return 1 unless config && config['hosts']
+
+          config['hosts'].each do |host|
+            name = "#{host['settings']['server_id']}--#{host['settings']['hostname']}.#{host['settings']['domain']}"
+            @env.ui.info(I18n.t('vagrant_startcloud.command.configuring', name: name))
+
+            with_target_vms([name]) do |vm|
+              vm.config.startcloud.settings = host['settings']
+              vm.config.startcloud.networks = host['networks']
+              vm.config.startcloud.disks = host['disks']
+              vm.config.startcloud.provisioning = host['provisioning']
+              vm.config.startcloud.folders = host['folders']
+              vm.config.startcloud.roles = host['roles']
+              vm.config.startcloud.vars = host['vars']
+              vm.config.startcloud.plugins = host['plugins']
+              vm.config.startcloud.zones = host['zones']
+            end
+          end
+
+          0
+        rescue StandardError => e
+          @env.ui.error(I18n.t('vagrant_startcloud.config.yaml_error', error: e.message))
+          1
+        end
+      end
+    end
+  end
+end

data/lib/vagrant-startcloud/config.rb

@@ -0,0 +1,65 @@
+# frozen_string_literal: true
+
+module VagrantPlugins
+  module StartCloud
+    class Config < Vagrant.plugin('2', :config)
+      attr_accessor :config_path, :settings, :networks, :disks, :provisioning, :folders, :roles, :vars, :plugins, :zones
+
+      def initialize
+        super
+        @config_path = UNSET_VALUE
+        @settings = {}
+        @networks = []
+        @disks = {}
+        @provisioning = {}
+        @folders = []
+        @roles = []
+        @vars = {}
+        @plugins = {}
+        @zones = {}
+      end
+
+      def finalize!
+        @config_path = nil if @config_path == UNSET_VALUE
+      end
+
+      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)
+
+        if @settings.empty?
+          errors << I18n.t('vagrant_startcloud.config.no_settings')
+          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?
+
+        { 'StartCloud configuration' => errors }
+      end
+
+      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))
+      end
+    end
+  end
+end

data/lib/vagrant-startcloud/config_builder.rb

@@ -0,0 +1,88 @@
+# frozen_string_literal: true
+
+require 'log4r'
+
+module VagrantPlugins
+  module StartCloud
+    class ConfigBuilder
+      class << self
+        def load_config(config_path)
+          require 'yaml'
+          logger = Log4r::Logger.new('vagrant_startcloud::config_builder')
+          config = Config.new
+
+          if File.exist?(config_path)
+            logger.debug("Loading configuration from #{config_path}")
+            yaml_config = YAML.load_file(config_path)
+
+            if yaml_config && yaml_config['hosts']&.first
+              host = yaml_config['hosts'].first
+              config.settings = host['settings'] || {}
+              config.networks = host['networks'] || []
+              config.disks = host['disks'] || {}
+              config.provisioning = host['provisioning'] || {}
+              config.folders = host['folders'] || []
+              config.roles = host['roles'] || []
+              config.vars = host['vars'] || {}
+              config.plugins = host['plugins'] || {}
+              config.zones = host['zones'] || {}
+              config.config_path = config_path
+              logger.info('Configuration loaded successfully')
+            else
+              logger.warn('No hosts defined in configuration')
+              raise Errors::MissingHosts
+            end
+          else
+            logger.error("Configuration file not found: #{config_path}")
+            raise Errors::ConfigurationFileNotFound, path: config_path
+          end
+
+          config
+        rescue StandardError => e
+          logger.error("Error loading configuration: #{e.message}")
+          logger.error(e.backtrace.join("\n"))
+          raise Errors::InvalidConfigurationFormat, error: e.message
+        end
+
+        def validate_config(config)
+          logger = Log4r::Logger.new('vagrant_startcloud::config_builder')
+          errors = []
+
+          if config.settings.empty?
+            logger.error('No settings defined in configuration')
+            errors << I18n.t('vagrant_startcloud.config.no_settings')
+          else
+            required = %w[hostname domain server_id box]
+            missing = required.reject { |key| config.settings.key?(key) && !config.settings[key].to_s.empty? }
+            if missing.any?
+              logger.error("Missing required settings: #{missing.join(', ')}")
+              errors << I18n.t('vagrant_startcloud.config.missing_required', fields: missing.join(', '))
+            end
+          end
+
+          if config.networks&.any?
+            config.networks.each_with_index do |network, index|
+              unless network['type']
+                logger.error("Network type required for network at index #{index}")
+                errors << I18n.t('vagrant_startcloud.config.network_type_required', index: index)
+              end
+            end
+          end
+
+          errors << I18n.t('vagrant_startcloud.config.boot_disk_size_required') if config.disks&.any? && config.disks['boot'] && !config.disks['boot']['size']
+
+          if config.folders&.any?
+            config.folders.each_with_index do |folder, index|
+              unless folder['map'] && folder['to']
+                logger.error("Both 'map' and 'to' paths are required for folder at index #{index}")
+                errors << I18n.t('vagrant_startcloud.config.folder_paths_required', index: index)
+              end
+            end
+          end
+
+          errors
+        end
+      end
+    end
+  end
+end

data/lib/vagrant-startcloud/errors.rb

@@ -0,0 +1,84 @@
+# frozen_string_literal: true
+
+module VagrantPlugins
+  module StartCloud
+    module Errors
+      class StartCloudError < Vagrant::Errors::VagrantError
+        error_namespace('vagrant_startcloud.errors')
+      end
+
+      class ConfigurationFileNotFound < StartCloudError
+        error_key(:config_not_found)
+      end
+
+      class YAMLParseError < StartCloudError
+        error_key(:yaml_error)
+      end
+
+      class NoSettingsError < StartCloudError
+        error_key(:no_settings)
+      end
+
+      class MissingRequiredSettings < StartCloudError
+        error_key(:missing_required_setting)
+      end
+
+      class MissingHosts < StartCloudError
+        error_key(:missing_hosts)
+      end
+
+      class MissingSettings < StartCloudError
+        error_key(:missing_settings)
+      end
+
+      class NetworkTypeRequired < StartCloudError
+        error_key(:network_type_required)
+      end
+
+      class BootDiskSizeRequired < StartCloudError
+        error_key(:boot_disk_size_required)
+      end
+
+      class FolderPathsRequired < StartCloudError
+        error_key(:folder_paths_required)
+      end
+
+      class InvalidConfigurationFormat < StartCloudError
+        error_key(:invalid_format)
+      end
+
+      class MachineNotFound < StartCloudError
+        error_key(:machine_not_found)
+      end
+
+      # Provisioner errors
+      class VMConfigurationError < StartCloudError
+        error_key(:configuring_vm)
+      end
+
+      class SSHConfigurationError < StartCloudError
+        error_key(:configuring_ssh)
+      end
+
+      class NetworkConfigurationError < StartCloudError
+        error_key(:configuring_networks)
+      end
+
+      class ProviderConfigurationError < StartCloudError
+        error_key(:configuring_provider)
+      end
+
+      class FolderConfigurationError < StartCloudError
+        error_key(:configuring_folders)
+      end
+
+      class ShellProvisionerError < StartCloudError
+        error_key(:configuring_shell)
+      end
+
+      class AnsibleProvisionerError < StartCloudError
+        error_key(:configuring_ansible)
+      end
+    end
+  end
+end

data/lib/vagrant-startcloud/plugin.rb

@@ -0,0 +1,106 @@
+# frozen_string_literal: true
+
+require 'vagrant'
+
+module VagrantPlugins
+  module StartCloud
+    class Plugin < Vagrant.plugin('2')
+      @registered = []
+
+      name 'StartCloud'
+      description 'Provides support for provisioning machines using YAML configuration'
+
+      # Register config
+      config(:startcloud) do
+        require_relative 'config'
+        Config
+      end
+
+      # Register provisioner
+      config(:startcloud, :provisioner) do
+        require_relative 'config'
+        Config
+      end
+
+      provisioner(:startcloud) do
+        require_relative 'provisioner'
+        Provisioner
+      end
+
+      # Register command
+      command(:startcloud) do
+        require_relative 'command'
+        [VagrantPlugins::StartCloud::Command, { primary: true }]
+      end
+
+      # Register action hooks
+      action_hook(:startcloud_configure, :machine_action_up) do |hook|
+        require_relative 'action'
+        hook.before(Vagrant::Action::Builtin::ConfigValidate, Action.configure_machine)
+      end
+
+      # Register provider capabilities
+      provider_capability(:virtualbox, :configure_networks) do
+        require_relative 'action/configure_networks'
+        Action::ConfigureNetworks
+      end
+
+      provider_capability(:zones, :configure_networks) do
+        require_relative 'action/configure_networks'
+        Action::ConfigureNetworks
+      end
+
+      # Plugin registration
+      class << self
+        def registered
+          @registered ||= []
+        end
+
+        def registered?(name)
+          registered.include?(name)
+        end
+
+        def register(name)
+          registered << name unless registered?(name)
+        end
+
+        def version
+          VERSION
+        end
+
+        def components
+          @components ||= begin
+            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
+        end
+
+        def config_builder
+          require_relative 'config_builder'
+          ConfigBuilder
+        end
+      end
+
+      # Register plugin with Vagrant
+      register('vagrant-startcloud')
+
+      # Initialize I18n
+      def self.setup_i18n
+        I18n.load_path << File.expand_path('../../locales/en.yml', __dir__)
+        I18n.reload!
+      end
+
+      # Initialize plugin
+      def self.init!
+        setup_i18n
+      end
+
+      # Call initialization
+      init!
+    end
+  end
+end

data/lib/vagrant-startcloud/provisioner.rb

@@ -0,0 +1,101 @@
+# frozen_string_literal: true
+
+module VagrantPlugins
+  module StartCloud
+    class Provisioner < Vagrant.plugin('2', :provisioner)
+      def configure
+        settings = config.settings || {}
+        networks = config.networks || []
+        provisioning = config.provisioning || {}
+        folders = config.folders || []
+
+        configure_basic_settings(machine.config, settings)
+        configure_ssh_settings(machine.config, settings)
+        configure_networks(machine.config, networks)
+        configure_provider(machine.config, settings)
+        configure_shared_folders(machine.config, folders)
+        configure_provisioners(machine.config, provisioning)
+      end
+
+      private
+
+      def configure_basic_settings(root_config, settings)
+        root_config.vm.hostname = "#{settings['hostname']}.#{settings['domain']}"
+        root_config.vm.boot_timeout = settings['boot_timeout'] if settings['boot_timeout']
+      end
+
+      def configure_ssh_settings(root_config, settings)
+        root_config.ssh.insert_key = false
+        root_config.ssh.forward_agent = true
+        root_config.ssh.username = settings['vagrant_user'] if settings['vagrant_user']
+        root_config.ssh.private_key_path = settings['vagrant_user_private_key_path'] if settings['vagrant_user_private_key_path']
+      end
+
+      def configure_networks(root_config, networks)
+        networks.each do |network|
+          options = {
+            ip: network['address'],
+            netmask: network['netmask'],
+            gateway: network['gateway'],
+            dhcp: network['dhcp4'],
+            auto_config: network['autoconf']
+          }
+
+          root_config.vm.network network['type'], **options
+        end
+      end
+
+      def configure_provider(root_config, settings)
+        provider_type = settings['provider_type']&.to_sym
+        return unless provider_type
+
+        root_config.vm.provider(provider_type) do |provider|
+          provider.memory = settings['memory'] if settings['memory']
+          provider.cpus = settings['vcpus'] if settings['vcpus']
+
+          case provider_type
+          when :virtualbox
+            configure_virtualbox(provider, settings)
+          when :zones
+            configure_zones(provider, settings)
+          end
+        end
+      end
+
+      def configure_virtualbox(provider, settings)
+        provider.gui = settings['show_console'] if settings.key?('show_console')
+        provider.customize ['modifyvm', :id, '--ostype', settings['os_type']] if settings['os_type']
+      end
+
+      def configure_zones(provider, settings)
+        provider.brand = settings['brand'] if settings['brand']
+        provider.autostart = settings['autostart'] if settings.key?('autostart')
+      end
+
+      def configure_shared_folders(root_config, folders)
+        folders.each do |folder|
+          options = {
+            type: folder['type'],
+            owner: folder['owner'],
+            group: folder['group']
+          }.compact
+
+          root_config.vm.synced_folder folder['map'], folder['to'], **options
+        end
+      end
+
+      def configure_provisioners(root_config, provisioning)
+        configure_shell_provisioner(root_config, provisioning['shell']) if provisioning['shell']
+        configure_ansible_provisioner(root_config, provisioning['ansible']) if provisioning['ansible']
+      end
+
+      def configure_shell_provisioner(root_config, shell_config)
+        root_config.vm.provision 'shell', **shell_config
+      end
+
+      def configure_ansible_provisioner(root_config, ansible_config)
+        root_config.vm.provision 'ansible_local', **ansible_config
+      end
+    end
+  end
+end

data/lib/vagrant-startcloud/version.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module VagrantPlugins
+  module StartCloud
+    VERSION = '0.1.2'
+  end
+end

data/lib/vagrant-startcloud.rb

@@ -0,0 +1,94 @@
+# frozen_string_literal: true
+
+require 'pathname'
+require 'i18n'
+require 'vagrant'
+
+module VagrantPlugins
+  module StartCloud
+    lib_path = Pathname.new(File.expand_path('vagrant-startcloud', __dir__))
+
+    # Load all plugin files
+    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')
+
+    # This returns the path to the source of this plugin.
+    def self.source_root
+      @source_root ||= Pathname.new(File.expand_path('..', __dir__))
+    end
+
+    # This initializes the internationalization strings.
+    def self.init_i18n
+      I18n.load_path << File.expand_path('locales/en.yml', source_root)
+      I18n.reload!
+    rescue Errno::ENOENT
+      # During testing, the locale file might not be in the expected location
+      return if ENV['VAGRANT_ENV'] == 'test'
+
+      raise
+    end
+
+    # This initializes the logging system.
+    def self.init_logging
+      require 'log4r'
+
+      level = nil
+      begin
+        level = Log4r.const_get(ENV['VAGRANT_LOG'].upcase)
+      rescue NameError
+        level = Log4r::INFO
+      end
+
+      logger = Log4r::Logger.new('vagrant_startcloud')
+      logger.outputters = Log4r::Outputter.stderr
+      logger.level = level
+
+      logger
+    end
+
+    # This sets up our log level to be whatever VAGRANT_LOG is.
+    def self.setup_logging
+      level = nil
+      begin
+        level = Log4r.const_get(ENV['VAGRANT_LOG'].upcase)
+      rescue NameError
+        # This means that the logging constant wasn't found,
+        # which is fine, we just keep `level` as `nil`. But
+        # we tell the user.
+        level = nil
+      end
+
+      # Some constants, such as "true" resolve to booleans, so the
+      # above error checking doesn't catch it. This will check to make
+      # sure that the log level is an integer, as Log4r requires.
+      level = nil unless level.is_a?(Integer)
+
+      # Set the logging level on all "vagrant" namespaced
+      # logs as long as we have a valid level.
+      return unless level
+
+      logger = Log4r::Logger.new('vagrant_startcloud')
+      logger.outputters = Log4r::Outputter.stderr
+      logger.level = level
+      logger
+    end
+
+    # This initializes the plugin.
+    def self.init!
+      init_i18n
+      init_logging
+      setup_logging
+    end
+  end
+end
+
+# Load the plugin
+require 'vagrant-startcloud/plugin'
+
+# Initialize the plugin
+VagrantPlugins::StartCloud.init!