vagrant-startcloud 0.1.2 → 0.1.3

data/README.md

@@ -1,19 +1,10 @@
 # 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
+## Overview
 
-- 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
+This plugin allows you to define your Vagrant configuration in a YAML file (Hosts.yml) instead of a Ruby-based Vagrantfile. It supports both VirtualBox and Zones providers, and handles network configuration, disk management, shared folders, and more.
 
 ## Installation
 
@@ -23,157 +14,163 @@ vagrant plugin install vagrant-startcloud
 
 ## Usage
 
-1. Create a `Hosts.yml` file in your project directory:
+1. Create a minimal Vagrantfile:
+
+```ruby
+# Vagrantfile
+Vagrant.configure('2') do |config|
+  StartCloud.configure(config)
+end
+```
+
+2. Define your configuration in Hosts.yml:
 
 ```yaml
 hosts:
   - settings:
       hostname: web
       domain: example.com
-      server_id: '1001'
+      server_id: "1001"
       box: ubuntu/focal64
       provider_type: virtualbox
-      virtualbox:
-        memory: 2048
-        cpus: 2
+      memory: 2048
+      vcpus: 2
+      setup_wait: 300
+      vagrant_user: vagrant
+    
     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:
+        address: 192.168.56.10
+        netmask: 255.255.255.0
+        gateway: 192.168.56.1
+        dhcp4: false
+        autoconf: true
+
+    disks:
+      boot:
+        size: 40G
+      data:
+        size: 100G
+        mount: /data
 
-```bash
-vagrant startcloud up
+    folders:
+      - map: ./app
+        to: /var/www/app
+        type: rsync
+        owner: www-data
+        group: www-data
 ```
 
 ## Configuration Reference
 
 ### Settings
 
-- `hostname`: Machine hostname
+- `hostname`: VM 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)
+- `server_id`: Unique identifier for the VM
+- `box`: Vagrant box to use
+- `provider_type`: Provider to use (virtualbox or zones)
+- `memory`: Memory allocation in MB
+- `vcpus`: Number of virtual CPUs
+- `setup_wait`: Boot timeout in seconds
+- `vagrant_user`: SSH username
 
 ### Networks
 
 ```yaml
 networks:
-  - type: private_network
-    ip: 192.168.50.10
+  - type: private_network  # or public_network
+    address: 192.168.56.10
     netmask: 255.255.255.0
-    gateway: 192.168.50.1
-    dhcp: true
-    auto_config: true
+    gateway: 192.168.56.1
+    dhcp4: false
+    autoconf: true
+    mac: "00:11:22:33:44:55"  # optional
+    nic_type: "82540EM"       # optional
 ```
 
-### Shared Folders
+### Disks
 
 ```yaml
-folders:
-  - host: ./app
-    guest: /var/www/app
-    options:
-      type: rsync
-      owner: www-data
-      group: www-data
+disks:
+  boot:
+    size: 40G
+  additional_disks:
+    - volume_name: data
+      size: 100G
+      port: 1
 ```
 
-### Provisioners
+### Shared Folders
 
 ```yaml
-provisioning:
-  shell:
-    path: setup.sh
-    args: ['--debug']
-  ansible:
-    playbook: playbook.yml
-    install_mode: pip
+folders:
+  - map: ./local/path
+    to: /vm/path
+    type: rsync        # or nfs, virtualbox
+    owner: vagrant
+    group: vagrant
+    mount_options: []  # optional
 ```
 
-### Provider Settings
+### Provider-Specific Settings
 
 #### VirtualBox
 
 ```yaml
-virtualbox:
-  memory: 2048
-  cpus: 2
-  gui: false
-  customize:
-    - ['modifyvm', '{{.Name}}', '--cpuexecutioncap', '50']
+settings:
+  provider_type: virtualbox
+  show_console: false
+  firmware_type: UEFI  # optional
+  vbox:
+    directives:        # optional
+      - directive: usb
+        value: "on"
 ```
 
 #### Zones
 
 ```yaml
+settings:
+  provider_type: zones
 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
+  brand: bhyve
+  autostart: true
 ```
 
-2. Install dependencies:
-```bash
-bundle install
+## Converting from Traditional Vagrantfile
+
+This plugin replaces complex Vagrantfile configurations with a structured YAML format. For example, instead of:
+
+```ruby
+Vagrant.configure("2") do |config|
+  config.vm.define "web" do |web|
+    web.vm.box = "ubuntu/focal64"
+    web.vm.network "private_network", ip: "192.168.56.10"
+    web.vm.provider "virtualbox" do |vb|
+      vb.memory = 2048
+      vb.cpus = 2
+    end
+  end
+end
 ```
 
-3. Run tests:
-```bash
-bundle exec rake
-```
+You can use:
 
-4. Build and install locally:
-```bash
-bundle exec rake gem:install
+```yaml
+hosts:
+  - settings:
+      hostname: web
+      domain: example.com
+      box: ubuntu/focal64
+      provider_type: virtualbox
+      memory: 2048
+      vcpus: 2
+    networks:
+      - type: private_network
+        address: 192.168.56.10
 ```
 
-## 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
+AGPL-3.0

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

@@ -0,0 +1,78 @@
+# frozen_string_literal: true
+
+module VagrantPlugins
+  module StartCloud
+    module Action
+      class ConfigureDisks
+        def initialize(app, env)
+          @app = app
+          @env = env
+          @machine = env[:machine]
+          @provider = env[:provider]
+        end
+
+        def call(env)
+          config = @machine.config.startcloud
+          disks = config.disks
+
+          if disks && !disks.empty?
+            @machine.ui.info I18n.t('vagrant_startcloud.configuring.disks')
+
+            case @provider
+            when :virtualbox
+              configure_virtualbox_disks(disks)
+            when :zones
+              configure_zones_disks(disks)
+            end
+          end
+
+          @app.call(env)
+        end
+
+        private
+
+        def configure_virtualbox_disks(disks)
+          return unless disks['additional_disks']
+
+          disks_directory = File.join(@env[:root_path], 'disks')
+          FileUtils.mkdir_p(disks_directory) unless File.directory?(disks_directory)
+
+          disks['additional_disks'].each do |disk|
+            local_disk_filename = File.join(disks_directory, "#{disk['volume_name']}.vdi")
+
+            unless File.exist?(local_disk_filename)
+              disk_size_gb = disk['size'].match(/(\d+(\.\d+)?)/)[0].to_f
+              disk_size_mb = (disk_size_gb * 1024).to_i
+
+              @machine.provider.driver.create_disk(
+                local_disk_filename,
+                disk_size_mb,
+                { format: 'VDI' }
+              )
+            end
+
+            @machine.provider.driver.attach_disk(
+              local_disk_filename,
+              {
+                controller: 'SCSI',
+                port: disk['port'],
+                device: 0
+              }
+            )
+          end
+        end
+
+        def configure_zones_disks(disks)
+          return unless @machine.provider.capability?(:configure_disks)
+
+          disk_options = {
+            boot: disks['boot'],
+            additional: disks['additional_disks']
+          }.compact
+
+          @machine.provider.capability(:configure_disks, disk_options)
+        end
+      end
+    end
+  end
+end

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

@@ -22,8 +22,15 @@ module VagrantPlugins
                 netmask: network['netmask'],
                 gateway: network['gateway'],
                 dhcp: network['dhcp4'],
-                auto_config: network['autoconf']
-              }
+                dhcp4: network['dhcp4'],
+                dhcp6: network['dhcp6'],
+                auto_config: network['autoconf'],
+                mac: format_mac_address(network['mac'], @provider),
+                nic_type: network['nic_type'],
+                vlan: network['vlan'],
+                dns: network['dns'],
+                bridge: network['bridge']
+              }.compact
 
               case network['type']
               when 'host'
@@ -51,59 +58,58 @@ module VagrantPlugins
         end
 
         def configure_virtualbox_network(machine, type, options)
+          adapter_number = machine.provider.driver.read_network_interfaces.length + 1
+          network_options = {
+            adapter: adapter_number,
+            ip: options[:ip],
+            netmask: options[:netmask],
+            auto_config: options[:auto_config],
+            mac: options[:mac],
+            nic_type: options[:nic_type],
+            vlan: options[:vlan]
+          }.compact
+
           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]
-              }]
-            )
+            network_options[:type] = :static
+            machine.provider.capability(:configure_networks, [network_options])
           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]
-              }]
-            )
+            network_options[:type] = :bridged
+            network_options[:bridge] = options[:bridge] if options[:bridge]
+            machine.provider.capability(:configure_networks, [network_options])
           end
         end
 
         def configure_zones_network(machine, type, options)
+          network_options = {
+            type: :vnic,
+            ip: options[:ip],
+            netmask: options[:netmask],
+            gateway: options[:gateway],
+            dhcp4: options[:dhcp4],
+            dhcp6: options[:dhcp6],
+            autoconf: options[:auto_config],
+            mac: options[:mac],
+            dns: options[:dns]
+          }.compact
+
           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]
-              }]
-            )
+            machine.provider.capability(:configure_networks, [network_options])
           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]
-              }]
-            )
+            network_options[:public] = true
+            machine.provider.capability(:configure_networks, [network_options])
+          end
+        end
+
+        def format_mac_address(mac, provider)
+          return nil unless mac
+
+          case provider
+          when :virtualbox
+            mac.tr(':', '') # VirtualBox requires MAC without colons
+          else
+            mac # Other providers use standard MAC format
           end
         end
       end

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

@@ -4,24 +4,26 @@ module VagrantPlugins
   module StartCloud
     module Action
       class ConfigureProviders
-        def initialize(app, _env)
+        def initialize(app, env)
           @app = app
+          @env = env
+          @machine = env[:machine]
+          @provider = env[:provider]
         end
 
         def call(env)
-          machine = env[:machine]
-          config = machine.config.startcloud
+          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']))
+            @machine.ui.info I18n.t('vagrant_startcloud.configuring.provider',
+                                    provider: settings['provider_type'])
 
             case settings['provider_type']
             when 'virtualbox'
-              configure_virtualbox(machine, settings)
+              configure_virtualbox(settings)
             when 'zones'
-              configure_zones(machine, settings, config.zones)
+              configure_zones(settings, config.zones)
             end
           end
 
@@ -30,55 +32,49 @@ module VagrantPlugins
 
         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
+        def configure_virtualbox(settings)
+          @machine.provider.driver.customize ['modifyvm', @machine.id, '--memory', calculate_memory(settings['memory'])]
+          @machine.provider.driver.customize ['modifyvm', @machine.id, '--cpus', settings['vcpus']] if settings['vcpus']
+          @machine.provider.driver.customize ['modifyvm', @machine.id, '--ostype', settings['os_type']] if settings['os_type']
+
+          @machine.provider.driver.customize ['modifyvm', @machine.id, '--firmware', 'efi'] if settings['firmware_type'] == 'UEFI'
+
+          # Configure VirtualBox-specific settings
+          @machine.provider.driver.customize ['modifyvm', @machine.id, '--vrde', 'on']
+          @machine.provider.driver.customize ['modifyvm', @machine.id, '--natdnsproxy1', 'off']
+          @machine.provider.driver.customize ['modifyvm', @machine.id, '--natdnshostresolver1', 'off']
+          @machine.provider.driver.customize ['modifyvm', @machine.id, '--accelerate3d', 'off']
+          @machine.provider.driver.customize ['modifyvm', @machine.id, '--vram', '256']
+
+          # Apply custom VirtualBox directives if specified
+          return unless settings['vbox']&.dig('directives')
+
+          settings['vbox']['directives'].each do |directive|
+            @machine.provider.driver.customize ['modifyvm', @machine.id, "--#{directive['directive']}", directive['value']]
           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']
+        def configure_zones(settings, zones_config)
+          return unless @machine.provider.capability?(:configure_zone)
 
-            # Map settings to zones provider configuration
-            zones_config.each do |key, value|
-              zones.send("#{key}=", value) if zones.respond_to?("#{key}=")
-            end
+          zone_options = {
+            hostname: "#{settings['hostname']}.#{settings['domain']}",
+            brand: zones_config['brand'],
+            memory: settings['memory'],
+            cpus: settings['vcpus'],
+            autostart: zones_config['autostart']
+          }.compact
+
+          @machine.provider.capability(:configure_zone, zone_options)
+        end
+
+        def calculate_memory(memory)
+          return 1024 unless memory # Default to 1GB if not specified
 
-            # Set required settings
-            zones.memory = settings['memory']
-            zones.cpus = settings['vcpus']
-            zones.brand = zones_config['brand']
-            zones.image = zones_config['image']
+          if memory.to_s =~ /gb|g/i
+            1024 * memory.to_s.tr('^0-9', '').to_i
+          else
+            memory.to_s.tr('^0-9', '').to_i
           end
         end
       end