vagrant-aws-detiber 0.7.2.pre.2

data/vendor/bundle/ruby/2.3.0/bundler/gems/vagrant-419afb4dcffe/plugins/providers/virtualbox/driver/base.rb

@@ -0,0 +1,449 @@
+require 'log4r'
+
+require 'vagrant/util/busy'
+require 'vagrant/util/platform'
+require 'vagrant/util/retryable'
+require 'vagrant/util/subprocess'
+require 'vagrant/util/which'
+
+module VagrantPlugins
+  module ProviderVirtualBox
+    module Driver
+      # Base class for all VirtualBox drivers.
+      #
+      # This class provides useful tools for things such as executing
+      # VBoxManage and handling SIGINTs and so on.
+      class Base
+        # Include this so we can use `Subprocess` more easily.
+        include Vagrant::Util::Retryable
+
+        def initialize
+          @logger = Log4r::Logger.new("vagrant::provider::virtualbox::base")
+
+          # This flag is used to keep track of interrupted state (SIGINT)
+          @interrupted = false
+
+          if Vagrant::Util::Platform.windows? || Vagrant::Util::Platform.cygwin?
+            @logger.debug("Windows, checking for VBoxManage on PATH first")
+            @vboxmanage_path = Vagrant::Util::Which.which("VBoxManage")
+
+            # On Windows, we use the VBOX_INSTALL_PATH environmental
+            # variable to find VBoxManage.
+            if !@vboxmanage_path && (ENV.key?("VBOX_INSTALL_PATH") ||
+              ENV.key?("VBOX_MSI_INSTALL_PATH"))
+              @logger.debug("Windows. Trying VBOX_INSTALL_PATH for VBoxManage")
+
+              # Get the path.
+              path = ENV["VBOX_INSTALL_PATH"] || ENV["VBOX_MSI_INSTALL_PATH"]
+              @logger.debug("VBOX_INSTALL_PATH value: #{path}")
+
+              # There can actually be multiple paths in here, so we need to
+              # split by the separator ";" and see which is a good one.
+              path.split(";").each do |single|
+                # Make sure it ends with a \
+                single += "\\" if !single.end_with?("\\")
+
+                # If the executable exists, then set it as the main path
+                # and break out
+                vboxmanage = "#{single}VBoxManage.exe"
+                if File.file?(vboxmanage)
+                  @vboxmanage_path = Vagrant::Util::Platform.cygwin_windows_path(vboxmanage)
+                  break
+                end
+              end
+            end
+
+            # If we still don't have one, try to find it using common locations
+            drive = ENV["SYSTEMDRIVE"] || "C:"
+            [
+              "#{drive}/Program Files/Oracle/VirtualBox",
+              "#{drive}/Program Files (x86)/Oracle/VirtualBox",
+              "#{ENV["PROGRAMFILES"]}/Oracle/VirtualBox"
+            ].each do |maybe|
+              path = File.join(maybe, "VBoxManage.exe")
+              if File.file?(path)
+                @vboxmanage_path = path
+                break
+              end
+            end
+          elsif Vagrant::Util::Platform.wsl?
+            if !Vagrant::Util::Platform.wsl_windows_access?
+              @logger.error("No user Windows access defined for the Windows Subsystem for Linux. This is required for VirtualBox.")
+              raise Vagrant::Errors::WSLVirtualBoxWindowsAccessError
+            end
+            @logger.debug("Linux platform detected but executing within WSL. Locating VBoxManage.")
+            @vboxmanage_path = Vagrant::Util::Which.which("VBoxManage") || Vagrant::Util::Which.which("VBoxManage.exe")
+            if !@vboxmanage_path
+              raise Vagrant::Errors::VBoxManageNotFoundWSLError
+            end
+          end
+
+          # Fall back to hoping for the PATH to work out
+          @vboxmanage_path ||= "VBoxManage"
+          @logger.info("VBoxManage path: #{@vboxmanage_path}")
+        end
+
+        # Clears the forwarded ports that have been set on the virtual machine.
+        def clear_forwarded_ports
+        end
+
+        # Clears the shared folders that have been set on the virtual machine.
+        def clear_shared_folders
+        end
+
+        # Creates a DHCP server for a host only network.
+        #
+        # @param [String] network Name of the host-only network.
+        # @param [Hash] options Options for the DHCP server.
+        def create_dhcp_server(network, options)
+        end
+
+        # Creates a host only network with the given options.
+        #
+        # @param [Hash] options Options to create the host only network.
+        # @return [Hash] The details of the host only network, including
+        #   keys `:name`, `:ip`, and `:netmask`
+        def create_host_only_network(options)
+        end
+
+        # Deletes the virtual machine references by this driver.
+        def delete
+        end
+
+        # Deletes any host only networks that aren't being used for anything.
+        def delete_unused_host_only_networks
+        end
+
+        # Discards any saved state associated with this VM.
+        def discard_saved_state
+        end
+
+        # Enables network adapters on the VM.
+        #
+        # The format of each adapter specification should be like so:
+        #
+        # {
+        #   type:     :hostonly,
+        #   hostonly: "vboxnet0",
+        #   mac_address: "tubes"
+        # }
+        #
+        # This must support setting up both host only and bridged networks.
+        #
+        # @param [Array<Hash>] adapters Array of adapters to enable.
+        def enable_adapters(adapters)
+        end
+
+        # Execute a raw command straight through to VBoxManage.
+        #
+        # Accepts a retryable: true option if the command should be retried
+        # upon failure.
+        #
+        # Raises a VBoxManage error if it fails.
+        #
+        # @param [Array] command Command to execute.
+        def execute_command(command)
+        end
+
+        # Exports the virtual machine to the given path.
+        #
+        # @param [String] path Path to the OVF file.
+        # @yield [progress] Yields the block with the progress of the export.
+        def export(path)
+        end
+
+        # Forwards a set of ports for a VM.
+        #
+        # This will not affect any previously set forwarded ports,
+        # so be sure to delete those if you need to.
+        #
+        # The format of each port hash should be the following:
+        #
+        #     {
+        #       name: "foo",
+        #       hostport: 8500,
+        #       guestport: 80,
+        #       adapter: 1,
+        #       protocol: "tcp"
+        #     }
+        #
+        # Note that "adapter" and "protocol" are optional and will default
+        # to 1 and "tcp" respectively.
+        #
+        # @param [Array<Hash>] ports An array of ports to set. See documentation
+        #   for more information on the format.
+        def forward_ports(ports)
+        end
+
+        # Halts the virtual machine (pulls the plug).
+        def halt
+        end
+
+        # Imports the VM from an OVF file.
+        #
+        # @param [String] ovf Path to the OVF file.
+        # @return [String] UUID of the imported VM.
+        def import(ovf)
+        end
+
+        # Returns the maximum number of network adapters.
+        def max_network_adapters
+          8
+        end
+
+        # Returns a list of forwarded ports for a VM.
+        #
+        # @param [String] uuid UUID of the VM to read from, or `nil` if this
+        #   VM.
+        # @param [Boolean] active_only If true, only VMs that are running will
+        #   be checked.
+        # @return [Array<Array>]
+        def read_forwarded_ports(uuid=nil, active_only=false)
+        end
+
+        # Returns a list of bridged interfaces.
+        #
+        # @return [Hash]
+        def read_bridged_interfaces
+        end
+
+        # Returns a list of configured DHCP servers
+        #
+        # Each DHCP server is represented as a Hash with the following details:
+        #
+        # {
+        #  :network => String, # name of the associated network interface as
+        #                      #   parsed from the NetworkName, e.g. "vboxnet0"
+        #  :ip      => String, # IP address of the DHCP server, e.g. "172.28.128.2"
+        #  :lower   => String, # lower IP address of the DHCP lease range, e.g. "172.28.128.3"
+        #  :upper   => String, # upper IP address of the DHCP lease range, e.g. "172.28.128.254"
+        # }
+        #
+        # @return [Array<Hash>] See comment above for details
+        def read_dhcp_servers
+        end
+
+        # Returns the guest additions version that is installed on this VM.
+        #
+        # @return [String]
+        def read_guest_additions_version
+        end
+
+        # Returns the value of a guest property on the current VM.
+        #
+        # @param  [String] property the name of the guest property to read
+        # @return [String] value of the guest property
+        # @raise  [VirtualBoxGuestPropertyNotFound] if the guest property does not have a value
+        def read_guest_property(property)
+        end
+
+        # Returns a list of available host only interfaces.
+        #
+        # Each interface is represented as a Hash with the following details:
+        #
+        # {
+        #  :name    => String, # interface name, e.g. "vboxnet0"
+        #  :ip      => String, # IP address of the interface, e.g. "172.28.128.1"
+        #  :netmask => String, # netmask associated with the interface, e.g. "255.255.255.0"
+        #  :status  => String, # status of the interface, e.g. "Up", "Down"
+        # }
+        #
+        # @return [Array<Hash>] See comment above for details
+        def read_host_only_interfaces
+        end
+
+        # Returns the MAC address of the first network interface.
+        #
+        # @return [String]
+        def read_mac_address
+        end
+
+        # Returns the folder where VirtualBox places it's VMs.
+        #
+        # @return [String]
+        def read_machine_folder
+        end
+
+        # Returns a list of network interfaces of the VM.
+        #
+        # @return [Hash]
+        def read_network_interfaces
+        end
+
+        # Returns the current state of this VM.
+        #
+        # @return [Symbol]
+        def read_state
+        end
+
+        # Returns a list of all forwarded ports in use by active
+        # virtual machines.
+        #
+        # @return [Array]
+        def read_used_ports
+        end
+
+        # Returns a list of all UUIDs of virtual machines currently
+        # known by VirtualBox.
+        #
+        # @return [Array<String>]
+        def read_vms
+        end
+
+        # Reconfigure the hostonly network given by interface (the result
+        # of read_host_only_networks). This is a sad function that only
+        # exists to work around VirtualBox bugs.
+        #
+        # @return nil
+        def reconfig_host_only(interface)
+        end
+
+        # Removes the DHCP server identified by the provided network name.
+        #
+        # @param [String] network_name The the full network name associated
+        #   with the DHCP server to be removed, e.g. "HostInterfaceNetworking-vboxnet0"
+        def remove_dhcp_server(network_name)
+        end
+
+        # Sets the MAC address of the first network adapter.
+        #
+        # @param [String] mac MAC address without any spaces/hyphens.
+        def set_mac_address(mac)
+        end
+
+        # Share a set of folders on this VM.
+        #
+        # @param [Array<Hash>] folders
+        def share_folders(folders)
+        end
+
+        # Reads the SSH port of this VM.
+        #
+        # @param [Integer] expected Expected guest port of SSH.
+        def ssh_port(expected)
+        end
+
+        # Starts the virtual machine.
+        #
+        # @param [String] mode Mode to boot the VM. Either "headless"
+        #   or "gui"
+        def start(mode)
+        end
+
+        # Suspend the virtual machine.
+        def suspend
+        end
+
+        # Unshare folders.
+        def unshare_folders(names)
+        end
+
+        # Verifies that the driver is ready to accept work.
+        #
+        # This should raise a VagrantError if things are not ready.
+        def verify!
+        end
+
+        # Verifies that an image can be imported properly.
+        #
+        # @param [String] path Path to an OVF file.
+        # @return [Boolean]
+        def verify_image(path)
+        end
+
+        # Checks if a VM with the given UUID exists.
+        #
+        # @return [Boolean]
+        def vm_exists?(uuid)
+        end
+
+        # Execute the given subcommand for VBoxManage and return the output.
+        def execute(*command, &block)
+          # Get the options hash if it exists
+          opts = {}
+          opts = command.pop if command.last.is_a?(Hash)
+
+          tries = 0
+          tries = 3 if opts[:retryable]
+
+          # Variable to store our execution result
+          r = nil
+
+          retryable(on: Vagrant::Errors::VBoxManageError, tries: tries, sleep: 1) do
+            # If there is an error with VBoxManage, this gets set to true
+            errored = false
+
+            # Execute the command
+            r = raw(*command, &block)
+
+            # If the command was a failure, then raise an exception that is
+            # nicely handled by Vagrant.
+            if r.exit_code != 0
+              if @interrupted
+                @logger.info("Exit code != 0, but interrupted. Ignoring.")
+              elsif r.exit_code == 126
+                # This exit code happens if VBoxManage is on the PATH,
+                # but another executable it tries to execute is missing.
+                # This is usually indicative of a corrupted VirtualBox install.
+                raise Vagrant::Errors::VBoxManageNotFoundError
+              else
+                errored = true
+              end
+            else
+              # Sometimes, VBoxManage fails but doesn't actual return a non-zero
+              # exit code. For this we inspect the output and determine if an error
+              # occurred.
+
+              if r.stderr =~ /failed to open \/dev\/vboxnetctl/i
+                # This catches an error message that only shows when kernel
+                # drivers aren't properly installed.
+                @logger.error("Error message about unable to open vboxnetctl")
+                raise Vagrant::Errors::VirtualBoxKernelModuleNotLoaded
+              end
+
+              if r.stderr =~ /VBoxManage([.a-z]+?): error:/
+                # This catches the generic VBoxManage error case.
+                @logger.info("VBoxManage error text found, assuming error.")
+                errored = true
+              end
+            end
+
+            # If there was an error running VBoxManage, show the error and the
+            # output.
+            if errored
+              raise Vagrant::Errors::VBoxManageError,
+                command: command.inspect,
+                stderr:  r.stderr,
+                stdout:  r.stdout
+            end
+          end
+
+          # Return the output, making sure to replace any Windows-style
+          # newlines with Unix-style.
+          r.stdout.gsub("\r\n", "\n")
+        end
+
+        # Executes a command and returns the raw result object.
+        def raw(*command, &block)
+          int_callback = lambda do
+            @interrupted = true
+
+            # We have to execute this in a thread due to trap contexts
+            # and locks.
+            Thread.new { @logger.info("Interrupted.") }.join
+          end
+
+          # Append in the options for subprocess
+          command << { notify: [:stdout, :stderr] }
+
+          Vagrant::Util::Busy.busy(int_callback) do
+            Vagrant::Util::Subprocess.execute(@vboxmanage_path, *command, &block)
+          end
+        rescue Vagrant::Util::Subprocess::LaunchError => e
+          raise Vagrant::Errors::VBoxManageLaunchError,
+            message: e.to_s
+        end
+      end
+    end
+  end
+end

data/vendor/bundle/ruby/2.3.0/bundler/gems/vagrant-419afb4dcffe/plugins/providers/virtualbox/driver/meta.rb

@@ -0,0 +1,187 @@
+require "forwardable"
+require "thread"
+
+require "log4r"
+
+require "vagrant/util/retryable"
+
+require File.expand_path("../base", __FILE__)
+
+module VagrantPlugins
+  module ProviderVirtualBox
+    module Driver
+      class Meta < Base
+        # This is raised if the VM is not found when initializing a driver
+        # with a UUID.
+        class VMNotFound < StandardError; end
+
+        # We use forwardable to do all our driver forwarding
+        extend Forwardable
+
+        # We cache the read VirtualBox version here once we have one,
+        # since during the execution of Vagrant, it likely doesn't change.
+        @@version = nil
+        @@version_lock = Mutex.new
+
+        # The UUID of the virtual machine we represent
+        attr_reader :uuid
+
+        # The version of virtualbox that is running.
+        attr_reader :version
+
+        include Vagrant::Util::Retryable
+
+        def initialize(uuid=nil)
+          # Setup the base
+          super()
+
+          @logger = Log4r::Logger.new("vagrant::provider::virtualbox::meta")
+          @uuid = uuid
+
+          @@version_lock.synchronize do
+            if !@@version
+              # Read and assign the version of VirtualBox we know which
+              # specific driver to instantiate.
+              begin
+                @@version = read_version
+              rescue Vagrant::Errors::CommandUnavailable,
+                Vagrant::Errors::CommandUnavailableWindows
+                # This means that VirtualBox was not found, so we raise this
+                # error here.
+                raise Vagrant::Errors::VirtualBoxNotDetected
+              end
+            end
+          end
+
+          # Instantiate the proper version driver for VirtualBox
+          @logger.debug("Finding driver for VirtualBox version: #{@@version}")
+          driver_map   = {
+            "4.0" => Version_4_0,
+            "4.1" => Version_4_1,
+            "4.2" => Version_4_2,
+            "4.3" => Version_4_3,
+            "5.0" => Version_5_0,
+            "5.1" => Version_5_1,
+            "5.2" => Version_5_2,
+          }
+
+          if @@version.start_with?("4.2.14")
+            # VirtualBox 4.2.14 just doesn't work with Vagrant, so show error
+            raise Vagrant::Errors::VirtualBoxBrokenVersion040214
+          end
+
+          driver_klass = nil
+          driver_map.each do |key, klass|
+            if @@version.start_with?(key)
+              driver_klass = klass
+              break
+            end
+          end
+
+          if !driver_klass
+            supported_versions = driver_map.keys.sort.join(", ")
+            raise Vagrant::Errors::VirtualBoxInvalidVersion,
+              supported_versions: supported_versions
+          end
+
+          @logger.info("Using VirtualBox driver: #{driver_klass}")
+          @driver = driver_klass.new(@uuid)
+          @version = @@version
+
+          if @uuid
+            # Verify the VM exists, and if it doesn't, then don't worry
+            # about it (mark the UUID as nil)
+            raise VMNotFound if !@driver.vm_exists?(@uuid)
+          end
+        end
+
+        def_delegators :@driver, :clear_forwarded_ports,
+          :clear_shared_folders,
+          :clonevm,
+          :create_dhcp_server,
+          :create_host_only_network,
+          :create_snapshot,
+          :delete,
+          :delete_snapshot,
+          :delete_unused_host_only_networks,
+          :discard_saved_state,
+          :enable_adapters,
+          :execute_command,
+          :export,
+          :forward_ports,
+          :halt,
+          :import,
+          :list_snapshots,
+          :read_forwarded_ports,
+          :read_bridged_interfaces,
+          :read_dhcp_servers,
+          :read_guest_additions_version,
+          :read_guest_ip,
+          :read_guest_property,
+          :read_host_only_interfaces,
+          :read_mac_address,
+          :read_mac_addresses,
+          :read_machine_folder,
+          :read_network_interfaces,
+          :read_state,
+          :read_used_ports,
+          :read_vms,
+          :reconfig_host_only,
+          :remove_dhcp_server,
+          :restore_snapshot,
+          :resume,
+          :set_mac_address,
+          :set_name,
+          :share_folders,
+          :ssh_port,
+          :start,
+          :suspend,
+          :verify!,
+          :verify_image,
+          :vm_exists?
+
+        protected
+
+        # This returns the version of VirtualBox that is running.
+        #
+        # @return [String]
+        def read_version
+          # The version string is usually in one of the following formats:
+          #
+          # * 4.1.8r1234
+          # * 4.1.8r1234_OSE
+          # * 4.1.8_MacPortsr1234
+          #
+          # Below accounts for all of these.
+
+          # Note: We split this into multiple lines because apparently "".split("_")
+          # is [], so we have to check for an empty array in between.
+          output = ""
+          retryable(on: Vagrant::Errors::VirtualBoxVersionEmpty, tries: 3, sleep: 1) do
+            output = execute("--version")
+            if output =~ /vboxdrv kernel module is not loaded/ ||
+              output =~ /VirtualBox kernel modules are not loaded/i
+              raise Vagrant::Errors::VirtualBoxKernelModuleNotLoaded
+            elsif output =~ /Please install/
+              # Check for installation incomplete warnings, for example:
+              # "WARNING: The character device /dev/vboxdrv does not
+              # exist. Please install the virtualbox-ose-dkms package and
+              # the appropriate headers, most likely linux-headers-generic."
+              raise Vagrant::Errors::VirtualBoxInstallIncomplete
+            elsif output.chomp == ""
+              # This seems to happen on Windows for uncertain reasons.
+              # Raise an error otherwise the error is that they have an
+              # incompatible version of VirtualBox which isn't true.
+              raise Vagrant::Errors::VirtualBoxVersionEmpty,
+                vboxmanage: @vboxmanage_path.to_s
+            end
+          end
+
+          parts = output.split("_")
+          return nil if parts.empty?
+          parts[0].split("r")[0]
+        end
+      end
+    end
+  end
+end