vagrant-veertu 0.0.12

data/lib/vagrant-veertu/errors.rb

@@ -0,0 +1,18 @@
+module VagrantPlugins
+  module ProviderVeertu
+    module Errors
+      class VeertuError < Vagrant::Errors::VagrantError
+        error_namespace('vagrant_veertu.errors')
+      end
+      class VeertuUnsupported < VeertuError
+        error_key(:veertumanage_unsupported)
+      end
+      class VeertuManageError < VeertuError
+        error_key(:veertumanage_error)
+      end
+      class VeertuManageNotFoundError < VeertuManageError
+        error_key(:veertumanage_notfound_error)
+      end
+    end
+  end
+end

data/lib/vagrant-veertu/model/forwarded_port.rb

@@ -0,0 +1,70 @@
+module VagrantPlugins
+  module ProviderVeertu
+    module Model
+      # Represents a single forwarded port for VirtualBox. This has various
+      # helpers and defaults for a forwarded port.
+      class ForwardedPort
+        # The NAT adapter on which to attach the forwarded port.
+        #
+        # @return [Integer]
+        attr_reader :adapter
+
+        # If true, this port should be auto-corrected.
+        #
+        # @return [Boolean]
+        attr_reader :auto_correct
+
+        # The unique ID for the forwarded port.
+        #
+        # @return [String]
+        attr_reader :id
+
+        # The protocol to forward.
+        #
+        # @return [String]
+        attr_reader :protocol
+
+        # The IP that the forwarded port will connect to on the guest machine.
+        #
+        # @return [String]
+        attr_reader :guest_ip
+
+        # The port on the guest to be exposed on the host.
+        #
+        # @return [Integer]
+        attr_reader :guest_port
+
+        # The IP that the forwarded port will bind to on the host machine.
+        #
+        # @return [String]
+        attr_reader :host_ip
+
+        # The port on the host used to access the port on the guest.
+        #
+        # @return [Integer]
+        attr_reader :host_port
+
+        def initialize(id, host_port, guest_port, options)
+          @id         = id
+          @guest_port = guest_port
+          @host_port  = host_port
+
+          options ||= {}
+          @auto_correct = false
+          @auto_correct = options[:auto_correct] if options.key?(:auto_correct)
+          @adapter  = (options[:adapter] || 1).to_i
+          @guest_ip = options[:guest_ip] || nil
+          @host_ip = options[:host_ip] || nil
+          @protocol = options[:protocol] || "tcp"
+        end
+
+        # This corrects the host port and changes it to the given new port.
+        #
+        # @param [Integer] new_port The new port
+        def correct_host_port(new_port)
+          @host_port = new_port
+        end
+      end
+    end
+  end
+end

data/lib/vagrant-veertu/plugin.rb

@@ -0,0 +1,76 @@
+require "vagrant"
+
+module VagrantPlugins
+  module ProviderVeertu
+    class Plugin < Vagrant.plugin("2")
+      name "Veertu provider"
+      description <<-EOF
+      The Veertu provider allows Vagrant to manage and control
+      Veertu-based virtual machines.
+      EOF
+
+      provider(:veertu, priority: 6) do
+        require File.expand_path("../provider", __FILE__)
+        Provider
+      end
+
+      config(:veertu, :provider) do
+        require File.expand_path("../config", __FILE__)
+        Config
+      end
+
+      config(:veertu, :provider) do
+        require File.expand_path("../config", __FILE__)
+        setup_i18n
+        Config
+      end
+
+      synced_folder(:veertu) do
+        require File.expand_path("../synced_folder", __FILE__)
+        SyncedFolder
+      end
+
+      provider_capability(:veertu, :forwarded_ports) do
+        require_relative "cap"
+        Cap
+      end
+
+      provider_capability(:veertu, :nic_mac_addresses) do
+        require_relative "cap"
+        Cap
+      end
+
+      provider_capability(:veertu, :public_address) do
+        require_relative "cap/public_address"
+        Cap::PublicAddress
+      end
+
+      provider_capability(:veertu, :snapshot_list) do
+        require_relative "cap"
+        Cap
+      end
+
+      def self.setup_i18n
+        I18n.load_path << File.expand_path("locales/en.yml", ProviderVeertu.source_root)
+        I18n.reload!
+      end
+    end
+
+    autoload :Action, File.expand_path("../action", __FILE__)
+
+    # Drop some autoloads in here to optimize the performance of loading
+    # our drivers only when they are needed.
+    module Driver
+      autoload :Meta, File.expand_path("../driver/meta", __FILE__)
+      autoload :Version_5_0, File.expand_path("../driver/version_5_0", __FILE__)
+    end
+
+    module Model
+      autoload :ForwardedPort, File.expand_path("../model/forwarded_port", __FILE__)
+    end
+
+    module Util
+      autoload :CompileForwardedPorts, File.expand_path("../util/compile_forwarded_ports", __FILE__)
+    end
+  end
+end

data/lib/vagrant-veertu/provider.rb

@@ -0,0 +1,121 @@
+require "log4r"
+
+module VagrantPlugins
+  module ProviderVeertu
+    class Provider < Vagrant.plugin("2", :provider)
+      attr_reader :driver
+
+      def self.installed?
+        Driver::Meta.new
+        true
+      rescue Vagrant::Errors::VirtualBoxInvalidVersion
+        return false
+      rescue Vagrant::Errors::VirtualBoxNotDetected
+        return false
+      end
+
+      def self.usable?(raise_error=false)
+        # Instantiate the driver, which will determine the VirtualBox
+        # version and all that, which checks for VirtualBox being present
+        Driver::Meta.new
+        true
+      rescue Vagrant::Errors::VirtualBoxInvalidVersion
+        raise if raise_error
+        return false
+      rescue Vagrant::Errors::VirtualBoxNotDetected
+        raise if raise_error
+        return false
+      end
+
+      def initialize(machine)
+        @logger  = Log4r::Logger.new("vagrant::provider::veertu")
+        @machine = machine
+
+        # This method will load in our driver, so we call it now to
+        # initialize it.
+        machine_id_changed
+      end
+
+      # @see Vagrant::Plugin::V1::Provider#action
+      def action(name)
+        # Attempt to get the action method from the Action class if it
+        # exists, otherwise return nil to show that we don't support the
+        # given action.
+        action_method = "action_#{name}"
+        return Action.send(action_method) if Action.respond_to?(action_method)
+        nil
+      end
+
+      # If the machine ID changed, then we need to rebuild our underlying
+      # driver.
+      def machine_id_changed
+        id = @machine.id
+
+        begin
+          @logger.debug("Instantiating the driver for machine ID: #{@machine.id.inspect}")
+          @driver = Driver::Meta.new(id)
+        rescue Driver::Meta::VMNotFound
+          # The virtual machine doesn't exist, so we probably have a stale
+          # ID. Just clear the id out of the machine and reload it.
+          @logger.debug("VM not found! Clearing saved machine ID and reloading.")
+          id = nil
+          retry
+        end
+      end
+
+      # Returns the SSH info for accessing the VirtualBox VM.
+      def ssh_info
+        # If the VM is not running that we can't possibly SSH into it
+        return nil if state.id != :running
+        local_port = @driver.ssh_port(@machine.config.ssh.guest_port)
+        return {
+          host: "127.0.0.1",
+          port: local_port
+        }
+      end
+
+      # Return the state of Veertu virtual machine by actually
+      # querying VeertuManage.
+      #
+      # @return [Symbol]
+      def state
+        #puts caller
+        # We have to check if the UID matches to avoid issues with
+        # VirtualBox.
+        uid = @machine.uid
+        if uid && uid.to_s != Process.uid.to_s
+          raise Vagrant::Errors::VirtualBoxUserMismatch,
+            original_uid: uid.to_s,
+            uid: Process.uid.to_s
+        end
+        # Determine the ID of the state here.
+        state_id = nil
+        state_id = :not_created if !@driver.uuid
+        state_id = @driver.read_state if !state_id
+        state_id = :unknown if !state_id
+        
+        # Translate into short/long descriptions
+        short = state_id.to_s.gsub("_", " ")
+        long  = I18n.t("vagrant.commands.status.#{state_id}")
+
+        # If we're not created, then specify the special ID flag
+        if state_id == :not_created
+          state_id = Vagrant::MachineState::NOT_CREATED_ID
+        end
+        # Return the state
+        state_to_ret = Vagrant::MachineState.new(state_id, short, long)
+        return state_to_ret
+      end
+
+      # Returns a human-friendly string version of this provider which
+      # includes the machine's ID that this provider represents, if it
+      # has one.
+      #
+      # @return [String]
+      def to_s
+        id = @machine.id ? @machine.id : "new VM"
+        "VirtualBox (#{id})"
+      end
+    end
+  end
+end

data/lib/vagrant-veertu/synced_folder.rb

@@ -0,0 +1,120 @@
+require "vagrant/util/platform"
+
+module VagrantPlugins
+  module ProviderVeertu
+    class SyncedFolder < Vagrant.plugin("2", :synced_folder)
+      def usable?(machine, raise_errors=false)
+        # These synced folders only work if the provider if VirtualBox
+        return false if machine.provider_name != :virtualbox
+
+        # This only happens with `vagrant package --base`. Sigh.
+        return true if !machine.provider_config
+
+        machine.provider_config.functional_vboxsf
+      end
+
+      def prepare(machine, folders, _opts)
+        share_folders(machine, folders, false)
+      end
+
+      def enable(machine, folders, _opts)
+        share_folders(machine, folders, true)
+
+        # short guestpaths first, so we don't step on ourselves
+        folders = folders.sort_by do |id, data|
+          if data[:guestpath]
+            data[:guestpath].length
+          else
+            # A long enough path to just do this at the end.
+            10000
+          end
+        end
+
+        # Go through each folder and mount
+        machine.ui.output(I18n.t("vagrant.actions.vm.share_folders.mounting"))
+        folders.each do |id, data|
+          if data[:guestpath]
+            # Guest path specified, so mount the folder to specified point
+            machine.ui.detail(I18n.t("vagrant.actions.vm.share_folders.mounting_entry",
+                                  guestpath: data[:guestpath],
+                                  hostpath: data[:hostpath]))
+
+            # Dup the data so we can pass it to the guest API
+            data = data.dup
+
+            # Calculate the owner and group
+            ssh_info = machine.ssh_info
+            data[:owner] ||= ssh_info[:username]
+            data[:group] ||= ssh_info[:username]
+
+            # Mount the actual folder
+            machine.guest.capability(
+              :mount_virtualbox_shared_folder,
+              os_friendly_id(id), data[:guestpath], data)
+          else
+            # If no guest path is specified, then automounting is disabled
+            machine.ui.detail(I18n.t("vagrant.actions.vm.share_folders.nomount_entry",
+                                  hostpath: data[:hostpath]))
+          end
+        end
+      end
+
+      def disable(machine, folders, _opts)
+        if machine.guest.capability?(:unmount_virtualbox_shared_folder)
+          folders.each do |id, data|
+            machine.guest.capability(
+              :unmount_virtualbox_shared_folder,
+              data[:guestpath], data)
+          end
+        end
+
+        # Remove the shared folders from the VM metadata
+        names = folders.map { |id, _data| os_friendly_id(id) }
+        driver(machine).unshare_folders(names)
+      end
+
+      def cleanup(machine, opts)
+        driver(machine).clear_shared_folders if machine.id && machine.id != ""
+      end
+
+      protected
+
+      # This is here so that we can stub it for tests
+      def driver(machine)
+        machine.provider.driver
+      end
+
+      def os_friendly_id(id)
+        id.gsub(/[\/]/,'_').sub(/^_/, '')
+      end
+
+      # share_folders sets up the shared folder definitions on the
+      # VirtualBox VM.
+      #
+      # The transient parameter determines if we're FORCING transient
+      # or not. If this is false, then any shared folders will be
+      # shared as non-transient unless they've specifically asked for
+      # transient.
+      def share_folders(machine, folders, transient)
+        defs = []
+        folders.each do |id, data|
+          hostpath = data[:hostpath]
+          if !data[:hostpath_exact]
+            hostpath = Vagrant::Util::Platform.cygwin_windows_path(hostpath)
+          end
+
+          # Only setup the shared folders that match our transient level
+          if (!!data[:transient]) == transient
+            defs << {
+              name: os_friendly_id(id),
+              hostpath: hostpath.to_s,
+              transient: transient,
+            }
+          end
+        end
+
+        driver(machine).share_folders(defs)
+      end
+    end
+  end
+end

data/lib/vagrant-veertu/util/compile_forwarded_ports.rb

@@ -0,0 +1,35 @@
+require "vagrant/util/scoped_hash_override"
+
+module VagrantPlugins
+  module ProviderVeertu
+    module Util
+      module CompileForwardedPorts
+        include Vagrant::Util::ScopedHashOverride
+
+        # This method compiles the forwarded ports into {ForwardedPort}
+        # models.
+        def compile_forwarded_ports(config)
+          mappings = {}
+
+          config.vm.networks.each do |type, options|
+            if type == :forwarded_port
+              guest_port = options[:guest]
+              host_port  = options[:host]
+              protocol   = options[:protocol] || "tcp"
+              options    = scoped_hash_override(options, :veertu)
+              id         = options[:id]
+
+              # If the forwarded port was marked as disabled, ignore.
+              next if options[:disabled]
+
+              mappings[host_port.to_s + protocol.to_s] =
+                Model::ForwardedPort.new(id, host_port, guest_port, options)
+            end
+          end
+
+          mappings.values
+        end
+      end
+    end
+  end
+end

data/lib/vagrant-veertu/version.rb

@@ -0,0 +1,5 @@
+module Vagrant
+  module Veertu
+    VERSION = "0.0.12"
+  end
+end