vagrant-startcloud 0.1.2

data/README.md

@@ -0,0 +1,179 @@
+# Vagrant StartCloud Plugin
+
+[![Gem Version](https://badge.fury.io/rb/vagrant-startcloud.svg)](https://badge.fury.io/rb/vagrant-startcloud)
+[![Build Status](https://github.com/STARTcloud/vagrant-startcloud/workflows/CI/badge.svg)](https://github.com/STARTcloud/vagrant-startcloud/actions)
+
+A Vagrant plugin that provides support for provisioning machines using YAML configuration with multi-provider support.
+
+## Features
+
+- YAML-based configuration for Vagrant machines
+- Support for multiple providers (VirtualBox, Zones, etc.)
+- Network configuration management
+- Shared folder configuration
+- Plugin management
+- Provisioner configuration (Shell, Ansible)
+- Provider-specific settings
+
+## Installation
+
+```bash
+vagrant plugin install vagrant-startcloud
+```
+
+## Usage
+
+1. Create a `Hosts.yml` file in your project directory:
+
+```yaml
+hosts:
+  - settings:
+      hostname: web
+      domain: example.com
+      server_id: '1001'
+      box: ubuntu/focal64
+      provider_type: virtualbox
+      virtualbox:
+        memory: 2048
+        cpus: 2
+    networks:
+      - type: private_network
+        ip: 192.168.50.10
+    folders:
+      - host: ./app
+        guest: /var/www/app
+        options:
+          type: rsync
+    provisioning:
+      shell:
+        path: setup.sh
+```
+
+2. Run Vagrant with the StartCloud plugin:
+
+```bash
+vagrant startcloud up
+```
+
+## Configuration Reference
+
+### Settings
+
+- `hostname`: Machine hostname
+- `domain`: Domain name
+- `server_id`: Unique identifier for the machine
+- `box`: Vagrant box name
+- `box_version`: (Optional) Specific box version
+- `box_url`: (Optional) Custom box URL
+- `provider_type`: Provider to use (virtualbox, zones)
+
+### Networks
+
+```yaml
+networks:
+  - type: private_network
+    ip: 192.168.50.10
+    netmask: 255.255.255.0
+    gateway: 192.168.50.1
+    dhcp: true
+    auto_config: true
+```
+
+### Shared Folders
+
+```yaml
+folders:
+  - host: ./app
+    guest: /var/www/app
+    options:
+      type: rsync
+      owner: www-data
+      group: www-data
+```
+
+### Provisioners
+
+```yaml
+provisioning:
+  shell:
+    path: setup.sh
+    args: ['--debug']
+  ansible:
+    playbook: playbook.yml
+    install_mode: pip
+```
+
+### Provider Settings
+
+#### VirtualBox
+
+```yaml
+virtualbox:
+  memory: 2048
+  cpus: 2
+  gui: false
+  customize:
+    - ['modifyvm', '{{.Name}}', '--cpuexecutioncap', '50']
+```
+
+#### Zones
+
+```yaml
+zones:
+  memory: 2048
+  cpus: 2
+  brand: lx
+  image: ubuntu-20.04
+```
+
+## Commands
+
+- `vagrant startcloud`: Main command
+- `vagrant startcloud --list`: List configured machines
+- `vagrant startcloud --config FILE`: Use custom config file
+- `vagrant startcloud MACHINE`: Configure specific machine
+
+## Development
+
+1. Clone the repository:
+```bash
+git clone https://github.com/STARTcloud/vagrant-startcloud.git
+cd vagrant-startcloud
+```
+
+2. Install dependencies:
+```bash
+bundle install
+```
+
+3. Run tests:
+```bash
+bundle exec rake
+```
+
+4. Build and install locally:
+```bash
+bundle exec rake gem:install
+```
+
+## Contributing
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request
+
+## License
+
+This project is licensed under the AGPL-3.0 License - see the [LICENSE](LICENSE) file for details.
+
+## Authors
+
+- Mark Gilbert ([@Makr91](https://github.com/Makr91))
+- Mark Gilbert ([@MarkProminic](https://github.com/MarkProminic))
+
+## Acknowledgments
+
+- Based on the core_provisioner concept
+- Inspired by vagrant-zones and vagrant-scp-sync plugins

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

@@ -0,0 +1,112 @@
+# frozen_string_literal: true
+
+module VagrantPlugins
+  module StartCloud
+    module Action
+      class ConfigureNetworks
+        def initialize(app, env)
+          @app = app
+          @provider = env[:provider] || :virtualbox
+        end
+
+        def call(env)
+          machine = env[:machine]
+          config = machine.config.startcloud
+
+          if config.networks&.any?
+            machine.ui.info I18n.t('vagrant_startcloud.provisioner.configuring_networks')
+
+            config.networks.each do |network|
+              options = {
+                ip: network['address'],
+                netmask: network['netmask'],
+                gateway: network['gateway'],
+                dhcp: network['dhcp4'],
+                auto_config: network['autoconf']
+              }
+
+              case network['type']
+              when 'host'
+                configure_network(machine, 'private_network', options)
+              else
+                configure_network(machine, network['type'], options)
+              end
+            rescue StandardError => e
+              raise Errors::NetworkConfigurationError, error: e.message
+            end
+          end
+
+          @app.call(env)
+        end
+
+        private
+
+        def configure_network(machine, type, options)
+          case @provider
+          when :virtualbox
+            configure_virtualbox_network(machine, type, options)
+          when :zone
+            configure_zones_network(machine, type, options)
+          end
+        end
+
+        def configure_virtualbox_network(machine, type, options)
+          case type
+          when 'private_network'
+            machine.provider.capability(
+              :configure_networks,
+              [{
+                type: :static,
+                adapter: machine.provider.driver.read_network_interfaces.length + 1,
+                ip: options[:ip],
+                netmask: options[:netmask],
+                auto_config: options[:auto_config]
+              }]
+            )
+          when 'public_network'
+            machine.provider.capability(
+              :configure_networks,
+              [{
+                type: :bridged,
+                adapter: machine.provider.driver.read_network_interfaces.length + 1,
+                ip: options[:ip],
+                netmask: options[:netmask],
+                auto_config: options[:auto_config]
+              }]
+            )
+          end
+        end
+
+        def configure_zones_network(machine, type, options)
+          case type
+          when 'private_network'
+            machine.provider.capability(
+              :configure_networks,
+              [{
+                type: :vnic,
+                ip: options[:ip],
+                netmask: options[:netmask],
+                gateway: options[:gateway],
+                dhcp4: options[:dhcp],
+                autoconf: options[:auto_config]
+              }]
+            )
+          when 'public_network'
+            machine.provider.capability(
+              :configure_networks,
+              [{
+                type: :vnic,
+                public: true,
+                ip: options[:ip],
+                netmask: options[:netmask],
+                gateway: options[:gateway],
+                dhcp4: options[:dhcp],
+                autoconf: options[:auto_config]
+              }]
+            )
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,87 @@
+# frozen_string_literal: true
+
+module VagrantPlugins
+  module StartCloud
+    module Action
+      class ConfigureProviders
+        def initialize(app, _env)
+          @app = app
+        end
+
+        def call(env)
+          machine = env[:machine]
+          config = machine.config.startcloud
+          settings = config.settings
+
+          if settings && settings['provider_type']
+            env[:ui].info(I18n.t('vagrant_startcloud.configuring.provider',
+                                 provider: settings['provider_type']))
+
+            case settings['provider_type']
+            when 'virtualbox'
+              configure_virtualbox(machine, settings)
+            when 'zones'
+              configure_zones(machine, settings, config.zones)
+            end
+          end
+
+          @app.call(env)
+        end
+
+        private
+
+        def configure_virtualbox(machine, settings)
+          machine.config.vm.provider :virtualbox do |vb|
+            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
+
+            vb.name = "#{settings['server_id']}--#{settings['hostname']}.#{settings['domain']}"
+            vb.gui = settings['show_console']
+            vb.customize ['modifyvm', :id, '--ostype', settings['os_type']] if settings['os_type']
+            vb.customize ['modifyvm', :id, '--vrdeport', settings['consoleport']] if settings['consoleport']
+            vb.customize ['modifyvm', :id, '--vrdeaddress', settings['consolehost']] if settings['consolehost']
+            vb.customize ['modifyvm', :id, '--cpus', settings['vcpus']] if settings['vcpus']
+            vb.customize ['modifyvm', :id, '--memory', memory] if memory.positive?
+            vb.customize ['modifyvm', :id, '--firmware', 'efi'] if settings['firmware_type'] == 'UEFI'
+
+            # Default VirtualBox settings
+            vb.customize ['modifyvm', :id, '--vrde', 'on']
+            vb.customize ['modifyvm', :id, '--natdnsproxy1', 'off']
+            vb.customize ['modifyvm', :id, '--natdnshostresolver1', 'off']
+            vb.customize ['modifyvm', :id, '--accelerate3d', 'off']
+            vb.customize ['modifyvm', :id, '--vram', '256']
+
+            # Apply custom VirtualBox directives if specified
+            if settings['vbox']&.dig('directives')
+              settings['vbox']['directives'].each do |directive|
+                vb.customize ['modifyvm', :id, "--#{directive['directive']}", directive['value']]
+              end
+            end
+          end
+        end
+
+        def configure_zones(machine, settings, zones_config)
+          machine.config.vm.provider :zones do |zones|
+            zones.hostname = "#{settings['subdomain']}.#{settings['domain']}"
+            zones.name = "#{settings['partition_id']}--#{settings['subdomain']}.#{settings['domain']}"
+            zones.partition_id = settings['server_id']
+
+            # Map settings to zones provider configuration
+            zones_config.each do |key, value|
+              zones.send("#{key}=", value) if zones.respond_to?("#{key}=")
+            end
+
+            # Set required settings
+            zones.memory = settings['memory']
+            zones.cpus = settings['vcpus']
+            zones.brand = zones_config['brand']
+            zones.image = zones_config['image']
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,116 @@
+# frozen_string_literal: true
+
+module VagrantPlugins
+  module StartCloud
+    module Action
+      class ConfigureProvisioners
+        def initialize(app, _env)
+          @app = app
+        end
+
+        def call(env)
+          machine = env[:machine]
+          config = machine.config.startcloud
+          provisioning = config.provisioning
+
+          if provisioning && !provisioning.empty?
+            env[:ui].info(I18n.t('vagrant_startcloud.configuring.provisioners'))
+
+            begin
+              configure_shell_provisioner(machine, provisioning['shell']) if provisioning['shell']&.dig('enabled')
+              configure_ansible_provisioner(machine, provisioning['ansible']) if provisioning['ansible']&.dig('enabled')
+              configure_docker_provisioner(machine, provisioning['docker']) if provisioning['docker']&.dig('enabled')
+            rescue StandardError => e
+              raise Errors::ProvisionerConfigurationFailed, error: e.message
+            end
+          end
+
+          @app.call(env)
+        end
+
+        private
+
+        def configure_shell_provisioner(machine, shell_config)
+          return unless shell_config['scripts']
+
+          shell_config['scripts'].each do |script|
+            machine.config.vm.provision 'shell', path: script
+          end
+        end
+
+        def configure_ansible_provisioner(machine, ansible_config)
+          return unless ansible_config['playbooks']
+
+          ansible_config['playbooks'].each do |playbooks|
+            configure_ansible_local(machine, playbooks['local']) if playbooks['local']
+
+            configure_ansible_remote(machine, playbooks['remote']) if playbooks['remote']
+          end
+        end
+
+        def configure_ansible_local(machine, playbooks)
+          playbooks.each do |playbook|
+            run_value = case playbook['run']
+                        when 'always'
+                          :always
+                        when 'not_first'
+                          File.exist?(File.join(Dir.pwd, 'results.yml')) ? :always : :never
+                        else
+                          :once
+                        end
+
+            machine.config.vm.provision :ansible_local, run: run_value do |ansible|
+              ansible.playbook = playbook['playbook']
+              ansible.compatibility_mode = playbook['compatibility_mode'].to_s
+              ansible.install_mode = 'pip' if playbook['install_mode'] == 'pip'
+              ansible.verbose = playbook['verbose']
+              ansible.config_file = '/vagrant/ansible/ansible.cfg'
+              ansible.galaxy_roles_path = '/vagrant'
+
+              if playbook['remote_collections']
+                ansible.galaxy_role_file = '/vagrant/ansible/requirements.yml'
+                ansible.galaxy_roles_path = '/vagrant/ansible/ansible_collections'
+              end
+            end
+          end
+        end
+
+        def configure_ansible_remote(machine, playbooks)
+          playbooks.each do |playbook|
+            run_value = case playbook['run']
+                        when 'always'
+                          :always
+                        when 'once'
+                          File.exist?(File.join(Dir.pwd, 'results.yml')) ? :never : :once
+                        when 'not_first'
+                          File.exist?(File.join(Dir.pwd, 'results.yml')) ? :always : :never
+                        else
+                          :once
+                        end
+
+            machine.config.vm.provision :ansible, run: run_value do |ansible|
+              ansible.playbook = playbook['playbook']
+              ansible.compatibility_mode = playbook['compatibility_mode'].to_s
+              ansible.verbose = playbook['verbose']
+
+              if playbook['remote_collections']
+                ansible.galaxy_role_file = 'requirements.yml'
+                ansible.galaxy_roles_path = './ansible/ansible_collections'
+              end
+            end
+          end
+        end
+
+        def configure_docker_provisioner(machine, docker_config)
+          machine.config.vm.provision 'docker'
+
+          return unless docker_config['docker_compose']
+
+          docker_config['docker_compose'].each do |file|
+            machine.config.vm.provision :docker_compose, yml: file, run: 'always'
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,71 @@
+# frozen_string_literal: true
+
+module VagrantPlugins
+  module StartCloud
+    module Action
+      class ConfigureSharedFolders
+        def initialize(app, _env)
+          @app = app
+        end
+
+        def call(env)
+          machine = env[:machine]
+          config = machine.config.startcloud
+
+          if config.folders&.any?
+            env[:ui].info('Configuring shared folders...')
+
+            config.folders.each do |folder|
+              configure_folder(machine, folder)
+            end
+          end
+
+          @app.call(env)
+        end
+
+        private
+
+        def configure_folder(machine, folder)
+          mount_opts = folder['type'] == 'virtualbox' ? ['actimeo=1'] : []
+
+          machine.config.vm.synced_folder(
+            folder['map'],
+            folder['to'],
+            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
+          )
+
+          # Configure syncback if enabled and scp-sync plugin is available
+          return unless folder['syncback'] && Vagrant.has_plugin?('vagrant-scp-sync')
+
+          configure_syncback(machine, folder)
+        end
+
+        def configure_syncback(machine, folder)
+          settings = machine.config.startcloud.settings
+          prefix = "==> #{settings['server_id']}--#{settings['hostname']}.#{settings['domain']}:"
+
+          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
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module VagrantPlugins
+  module StartCloud
+    module Action
+      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")
+
+          # 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
+  end
+end

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

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module VagrantPlugins
+  module StartCloud
+    module Action
+      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")
+
+          # 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
+  end
+end

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

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+require 'yaml'
+
+module VagrantPlugins
+  module StartCloud
+    module Action
+      class LoadConfig
+        def initialize(app, _env)
+          @app = app
+        end
+
+        def call(env)
+          machine = env[:machine]
+          config = machine.config.startcloud
+
+          if config.config_path && File.file?(config.config_path)
+            yaml_config = YAML.load_file(config.config_path)
+            host = yaml_config['hosts']&.find do |h|
+              name = "#{h['settings']['server_id']}--#{h['settings']['hostname']}.#{h['settings']['domain']}"
+              name == machine.name.to_s
+            end
+
+            if host
+              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'] || {}
+
+              env[:ui].info(I18n.t('vagrant_startcloud.config.loaded', name: machine.name))
+            else
+              env[:ui].warn(I18n.t('vagrant_startcloud.config.machine_not_found', name: machine.name))
+            end
+          else
+            env[:ui].warn(I18n.t('vagrant_startcloud.config.not_found', path: config.config_path))
+          end
+
+          @app.call(env)
+        end
+      end
+    end
+  end
+end