vagrant 1.0.7 → 1.5.0

data/lib/vagrant/downloaders.rb

@@ -1,7 +0,0 @@
-module Vagrant
-  module Downloaders
-    autoload :Base, 'vagrant/downloaders/base'
-    autoload :File, 'vagrant/downloaders/file'
-    autoload :HTTP, 'vagrant/downloaders/http'
-  end
-end

data/lib/vagrant/downloaders/base.rb

@@ -1,25 +0,0 @@
-module Vagrant
-  module Downloaders
-    # Represents a base class for a downloader. A downloader handles
-    # downloading a box file to a temporary file.
-    class Base
-      include Vagrant::Util
-
-      def initialize(ui)
-        @ui = ui
-      end
-
-      # Tests whether a URL matches this download. Subclasses must
-      # override this and return `true` for any URLs they wish to
-      # handle.
-      def self.match?(url); false; end
-
-      # Called prior to execution so any error checks can be done
-      def prepare(source_url); end
-
-      # Downloads the source file to the destination file. It is up to
-      # implementors of this class to handle the logic.
-      def download!(source_url, destination_file); end
-    end
-  end
-end

data/lib/vagrant/downloaders/file.rb

@@ -1,22 +0,0 @@
-require 'fileutils'
-
-module Vagrant
-  module Downloaders
-    # "Downloads" a file to a temporary file. Basically, this downloader
-    # simply does a file copy.
-    class File < Base
-      def self.match?(uri)
-        ::File.file?(::File.expand_path(uri))
-      end
-
-      def prepare(source_url)
-        raise Errors::DownloaderFileDoesntExist if !::File.file?(::File.expand_path(source_url))
-      end
-
-      def download!(source_url, destination_file)
-        @ui.info I18n.t("vagrant.downloaders.file.download")
-        FileUtils.cp(::File.expand_path(source_url), destination_file.path)
-      end
-    end
-  end
-end

data/lib/vagrant/downloaders/http.rb

@@ -1,97 +0,0 @@
-require 'net/http'
-require 'net/https'
-require 'uri'
-require 'base64'
-
-module Vagrant
-  module Downloaders
-    # Downloads a file from an HTTP URL to a temporary file. This
-    # downloader reports its progress to stdout while downloading.
-    class HTTP < Base
-      def self.match?(uri)
-        # URI.parse barfs on '<drive letter>:\\files \on\ windows'
-        extracted = URI.extract(uri).first
-        extracted && extracted.include?(uri)
-      end
-
-      def download!(source_url, destination_file)
-        uri = URI.parse(source_url)
-        proxy_uri = resolve_proxy(uri)
-
-        http = Net::HTTP.new(uri.host, uri.port, proxy_uri.host, proxy_uri.port, proxy_uri.user, proxy_uri.password)
-        http.read_timeout = nil # Disable the read timeout, just let it try to download
-
-        if uri.scheme == "https"
-          http.use_ssl = true
-          http.verify_mode = OpenSSL::SSL::VERIFY_NONE
-        end
-
-        http.start do |h|
-          @ui.info I18n.t("vagrant.downloaders.http.download", :url => source_url)
-
-          headers = nil
-          if uri.user && uri.password
-            headers = {'Authorization' => 'Basic ' + Base64.encode64(uri.user + ':' + uri.password)}
-          end
-
-          h.request_get(uri.request_uri, headers) do |response|
-            if response.is_a?(Net::HTTPRedirection)
-              # Follow the HTTP redirect.
-              # TODO: Error on some redirect limit
-              download!(response["Location"], destination_file)
-              return
-            elsif !response.is_a?(Net::HTTPOK)
-              raise Errors::DownloaderHTTPStatusError, :status => response.code
-            end
-
-            total = response.content_length
-            progress = 0
-            segment_count = 0
-
-            response.read_body do |segment|
-              # Report the progress out
-              progress += segment.length
-              segment_count += 1
-
-              # Progress reporting is limited to every 25 segments just so
-              # we're not constantly updating
-              if segment_count % 25 == 0
-                @ui.clear_line
-                @ui.report_progress(progress, total)
-                segment_count = 0
-              end
-
-              # Store the segment
-              destination_file.write(segment)
-            end
-
-            # Clear the line one last time so that the progress meter disappears
-            @ui.clear_line
-          end
-        end
-      rescue SocketError
-        raise Errors::DownloaderHTTPSocketError
-      end
-
-      private
-
-      # This method respects the "http_proxy" and "no_proxy" environmental
-      # variables so that HTTP proxies can properly be used with Vagrant.
-      def resolve_proxy(source_uri)
-        proxy_string = ENV["http_proxy"] || ""
-        if !proxy_string.empty? && ENV.has_key?("no_proxy")
-          # Respect the "no_proxy" environmental variable which contains a list
-          # of hosts that a proxy should not be used for.
-          ENV["no_proxy"].split(",").each do |host|
-            if source_uri.host =~ /#{Regexp.quote(host.strip)}$/
-              proxy_string = ""
-              break
-            end
-          end
-        end
-
-        URI.parse(proxy_string)
-      end
-    end
-  end
-end

data/lib/vagrant/driver.rb

@@ -1,8 +0,0 @@
-module Vagrant
-  module Driver
-    autoload :VirtualBox, 'vagrant/driver/virtualbox'
-    autoload :VirtualBox_4_0, 'vagrant/driver/virtualbox_4_0'
-    autoload :VirtualBox_4_1, 'vagrant/driver/virtualbox_4_1'
-    autoload :VirtualBox_4_2, 'vagrant/driver/virtualbox_4_2'
-  end
-end

data/lib/vagrant/driver/virtualbox.rb

@@ -1,134 +0,0 @@
-require 'forwardable'
-
-require 'log4r'
-
-require 'vagrant/driver/virtualbox_base'
-
-module Vagrant
-  module Driver
-    # This class contains the logic to drive VirtualBox.
-    #
-    # Read the VirtualBoxBase source for documentation on each method.
-    class VirtualBox < VirtualBoxBase
-      # 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
-
-      # The UUID of the virtual machine we represent
-      attr_reader :uuid
-
-      # The version of virtualbox that is running.
-      attr_reader :version
-
-      def initialize(uuid=nil)
-        # Setup the base
-        super()
-
-        @logger = Log4r::Logger.new("vagrant::driver::virtualbox")
-        @uuid = uuid
-
-        # Read and assign the version of VirtualBox we know which
-        # specific driver to instantiate.
-        begin
-          @version = read_version || ""
-        rescue Subprocess::LaunchError
-          # This means that VirtualBox was not found, so we raise this
-          # error here.
-          raise Errors::VirtualBoxNotDetected
-        end
-
-        # Instantiate the proper version driver for VirtualBox
-        @logger.debug("Finding driver for VirtualBox version: #{@version}")
-        driver_map   = {
-          "4.0" => VirtualBox_4_0,
-          "4.1" => VirtualBox_4_1,
-          "4.2" => VirtualBox_4_2
-        }
-
-        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 Errors::VirtualBoxInvalidVersion, :supported_versions => supported_versions
-        end
-
-        @logger.info("Using VirtualBox driver: #{driver_klass}")
-        @driver = driver_klass.new(@uuid)
-
-        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,
-                               :create_dhcp_server,
-                               :create_host_only_network,
-                               :delete,
-                               :delete_unused_host_only_networks,
-                               :discard_saved_state,
-                               :enable_adapters,
-                               :execute_command,
-                               :export,
-                               :forward_ports,
-                               :halt,
-                               :import,
-                               :read_forwarded_ports,
-                               :read_bridged_interfaces,
-                               :read_guest_additions_version,
-                               :read_host_only_interfaces,
-                               :read_mac_address,
-                               :read_machine_folder,
-                               :read_network_interfaces,
-                               :read_state,
-                               :read_used_ports,
-                               :read_vms,
-                               :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 = execute("--version")
-        if output =~ /vboxdrv kernel module is not loaded/
-          raise Errors::VirtualBoxKernelModuleNotLoaded
-        end
-
-        parts = output.split("_")
-        return nil if parts.empty?
-        parts[0].split("r")[0]
-      end
-    end
-  end
-end

data/lib/vagrant/driver/virtualbox_4_0.rb

@@ -1,459 +0,0 @@
-require 'log4r'
-
-require 'vagrant/driver/virtualbox_base'
-
-module Vagrant
-  module Driver
-    # Driver for VirtualBox 4.0.x
-    class VirtualBox_4_0 < VirtualBoxBase
-      def initialize(uuid)
-        super()
-
-        @logger = Log4r::Logger.new("vagrant::driver::virtualbox_4_0")
-        @uuid = uuid
-      end
-
-      def clear_forwarded_ports
-        args = []
-        read_forwarded_ports(@uuid).each do |nic, name, _, _|
-          args.concat(["--natpf#{nic}", "delete", name])
-        end
-
-        execute("modifyvm", @uuid, *args) if !args.empty?
-      end
-
-      def clear_shared_folders
-        info = execute("showvminfo", @uuid, "--machinereadable", :retryable => true)
-        info.split("\n").each do |line|
-          if line =~ /^SharedFolderNameMachineMapping\d+="(.+?)"$/
-            execute("sharedfolder", "remove", @uuid, "--name", $1.to_s)
-          end
-        end
-      end
-
-      def create_dhcp_server(network, options)
-        execute("dhcpserver", "add", "--ifname", network,
-                "--ip", options[:dhcp_ip],
-                "--netmask", options[:netmask],
-                "--lowerip", options[:dhcp_lower],
-                "--upperip", options[:dhcp_upper],
-                "--enable")
-      end
-
-      def create_host_only_network(options)
-        # Create the interface
-        execute("hostonlyif", "create") =~ /^Interface '(.+?)' was successfully created$/
-        name = $1.to_s
-
-        # Configure it
-        execute("hostonlyif", "ipconfig", name,
-                "--ip", options[:adapter_ip],
-                "--netmask", options[:netmask])
-
-        # Return the details
-        return {
-          :name => name,
-          :ip   => options[:adapter_ip],
-          :netmask => options[:netmask],
-          :dhcp => nil
-        }
-      end
-
-      def delete
-        execute("unregistervm", @uuid, "--delete")
-      end
-
-      def delete_unused_host_only_networks
-        networks = []
-        execute("list", "hostonlyifs").split("\n").each do |line|
-          networks << $1.to_s if line =~ /^Name:\s+(.+?)$/
-        end
-
-        execute("list", "vms").split("\n").each do |line|
-          if line =~ /^".+?"\s+\{(.+?)\}$/
-            info = execute("showvminfo", $1.to_s, "--machinereadable", :retryable => true)
-            info.split("\n").each do |line|
-              if line =~ /^hostonlyadapter\d+="(.+?)"$/
-                networks.delete($1.to_s)
-              end
-            end
-          end
-        end
-
-        networks.each do |name|
-          # First try to remove any DHCP servers attached. We use `raw` because
-          # it is okay if this fails. It usually means that a DHCP server was
-          # never attached.
-          raw("dhcpserver", "remove", "--ifname", name)
-
-          # Delete the actual host only network interface.
-          execute("hostonlyif", "remove", name)
-        end
-      end
-
-      def discard_saved_state
-        execute("discardstate", @uuid)
-      end
-
-      def enable_adapters(adapters)
-        args = []
-        adapters.each do |adapter|
-          args.concat(["--nic#{adapter[:adapter]}", adapter[:type].to_s])
-
-          if adapter[:bridge]
-            args.concat(["--bridgeadapter#{adapter[:adapter]}",
-                         adapter[:bridge]])
-          end
-
-          if adapter[:hostonly]
-            args.concat(["--hostonlyadapter#{adapter[:adapter]}",
-                         adapter[:hostonly]])
-          end
-
-          if adapter[:mac_address]
-            args.concat(["--macaddress#{adapter[:adapter]}",
-                         adapter[:mac_address]])
-          end
-
-          if adapter[:nic_type]
-            args.concat(["--nictype#{adapter[:adapter]}", adapter[:nic_type].to_s])
-          end
-        end
-
-        execute("modifyvm", @uuid, *args)
-      end
-
-      def execute_command(command)
-        raw(*command)
-      end
-
-      def export(path)
-        # TODO: Progress
-        execute("export", @uuid, "--output", path.to_s)
-      end
-
-      def forward_ports(ports)
-        args = []
-        ports.each do |options|
-          pf_builder = [options[:name],
-                        options[:protocol] || "tcp",
-                        "",
-                        options[:hostport],
-                        "",
-                        options[:guestport]]
-
-          args.concat(["--natpf#{options[:adapter] || 1}",
-                       pf_builder.join(",")])
-        end
-
-        execute("modifyvm", @uuid, *args) if !args.empty?
-      end
-
-      def halt
-        execute("controlvm", @uuid, "poweroff")
-      end
-
-      def import(ovf)
-        output = ""
-        total = ""
-        last  = 0
-        execute("import", ovf) do |type, data|
-          if type == :stdout
-            # Keep track of the stdout so that we can get the VM name
-            output << data
-          elsif type == :stderr
-            # Append the data so we can see the full view
-            total << data
-
-            # Break up the lines. We can't get the progress until we see an "OK"
-            lines = total.split("\n")
-            if lines.include?("OK.")
-              # The progress of the import will be in the last line. Do a greedy
-              # regular expression to find what we're looking for.
-              if lines.last =~ /.+(\d{2})%/
-                current = $1.to_i
-                if current > last
-                  last = current
-                  yield current if block_given?
-                end
-              end
-            end
-          end
-        end
-
-        # Find the name of the VM name
-        if output !~ /Suggested VM name "(.+?)"/
-          @logger.error("Couldn't find VM name in the output.")
-          return nil
-        end
-
-        name = $1.to_s
-
-        output = execute("list", "vms")
-        if output =~ /^"#{Regexp.escape(name)}" \{(.+?)\}$/
-          return $1.to_s
-        end
-
-        nil
-      end
-
-      def read_forwarded_ports(uuid=nil, active_only=false)
-        uuid ||= @uuid
-
-        @logger.debug("read_forward_ports: uuid=#{uuid} active_only=#{active_only}")
-
-        results = []
-        current_nic = nil
-        info = execute("showvminfo", uuid, "--machinereadable", :retryable => true)
-        info.split("\n").each do |line|
-          # This is how we find the nic that a FP is attached to,
-          # since this comes first.
-          current_nic = $1.to_i if line =~ /^nic(\d+)=".+?"$/
-
-          # If we care about active VMs only, then we check the state
-          # to verify the VM is running.
-          if active_only && line =~ /^VMState="(.+?)"$/ && $1.to_s != "running"
-            return []
-          end
-
-          # Parse out the forwarded port information
-          if line =~ /^Forwarding.+?="(.+?),.+?,.*?,(.+?),.*?,(.+?)"$/
-            result = [current_nic, $1.to_s, $2.to_i, $3.to_i]
-            @logger.debug("  - #{result.inspect}")
-            results << result
-          end
-        end
-
-        results
-      end
-
-      def read_bridged_interfaces
-        execute("list", "bridgedifs").split("\n\n").collect do |block|
-          info = {}
-
-          block.split("\n").each do |line|
-            if line =~ /^Name:\s+(.+?)$/
-              info[:name] = $1.to_s
-            elsif line =~ /^IPAddress:\s+(.+?)$/
-              info[:ip] = $1.to_s
-            elsif line =~ /^NetworkMask:\s+(.+?)$/
-              info[:netmask] = $1.to_s
-            elsif line =~ /^Status:\s+(.+?)$/
-              info[:status] = $1.to_s
-            end
-          end
-
-          # Return the info to build up the results
-          info
-        end
-      end
-
-      def read_guest_additions_version
-        output = execute("guestproperty", "get", @uuid, "/VirtualBox/GuestAdd/Version",
-                         :retryable => true)
-        if output =~ /^Value: (.+?)$/
-          # Split the version by _ since some distro versions modify it
-          # to look like this: 4.1.2_ubuntu, and the distro part isn't
-          # too important.
-          value = $1.to_s
-          return value.split("_").first
-        end
-
-        return nil
-      end
-
-      def read_host_only_interfaces
-        dhcp = {}
-        execute("list", "dhcpservers", :retryable => true).split("\n\n").each do |block|
-          info = {}
-
-          block.split("\n").each do |line|
-            if line =~ /^NetworkName:\s+HostInterfaceNetworking-(.+?)$/
-              info[:network] = $1.to_s
-            elsif line =~ /^IP:\s+(.+?)$/
-              info[:ip] = $1.to_s
-            elsif line =~ /^lowerIPAddress:\s+(.+?)$/
-              info[:lower] = $1.to_s
-            elsif line =~ /^upperIPAddress:\s+(.+?)$/
-              info[:upper] = $1.to_s
-            end
-          end
-
-          # Set the DHCP info
-          dhcp[info[:network]] = info
-        end
-
-        execute("list", "hostonlyifs", :retryable => true).split("\n\n").collect do |block|
-          info = {}
-
-          block.split("\n").each do |line|
-            if line =~ /^Name:\s+(.+?)$/
-              info[:name] = $1.to_s
-            elsif line =~ /^IPAddress:\s+(.+?)$/
-              info[:ip] = $1.to_s
-            elsif line =~ /^NetworkMask:\s+(.+?)$/
-              info[:netmask] = $1.to_s
-            elsif line =~ /^Status:\s+(.+?)$/
-              info[:status] = $1.to_s
-            end
-          end
-
-          # Set the DHCP info if it exists
-          info[:dhcp] = dhcp[info[:name]] if dhcp[info[:name]]
-
-          info
-        end
-      end
-
-      def read_mac_address
-        info = execute("showvminfo", @uuid, "--machinereadable", :retryable => true)
-        info.split("\n").each do |line|
-          return $1.to_s if line =~ /^macaddress1="(.+?)"$/
-        end
-
-        nil
-      end
-
-      def read_machine_folder
-        execute("list", "systemproperties", :retryable => true).split("\n").each do |line|
-          if line =~ /^Default machine folder:\s+(.+?)$/i
-            return $1.to_s
-          end
-        end
-
-        nil
-      end
-
-      def read_network_interfaces
-        nics = {}
-        info = execute("showvminfo", @uuid, "--machinereadable", :retryable => true)
-        info.split("\n").each do |line|
-          if line =~ /^nic(\d+)="(.+?)"$/
-            adapter = $1.to_i
-            type    = $2.to_sym
-
-            nics[adapter] ||= {}
-            nics[adapter][:type] = type
-          elsif line =~ /^hostonlyadapter(\d+)="(.+?)"$/
-            adapter = $1.to_i
-            network = $2.to_s
-
-            nics[adapter] ||= {}
-            nics[adapter][:hostonly] = network
-          elsif line =~ /^bridgeadapter(\d+)="(.+?)"$/
-            adapter = $1.to_i
-            network = $2.to_s
-
-            nics[adapter] ||= {}
-            nics[adapter][:bridge] = network
-          end
-        end
-
-        nics
-      end
-
-      def read_state
-        output = execute("showvminfo", @uuid, "--machinereadable", :retryable => true)
-        if output =~ /^name="<inaccessible>"$/
-          return :inaccessible
-        elsif output =~ /^VMState="(.+?)"$/
-          return $1.to_sym
-        end
-
-        nil
-      end
-
-      def read_used_ports
-        ports = []
-        execute("list", "vms", :retryable => true).split("\n").each do |line|
-          if line =~ /^".+?" \{(.+?)\}$/
-            uuid = $1.to_s
-
-            # Ignore our own used ports
-            next if uuid == @uuid
-
-            read_forwarded_ports(uuid, true).each do |_, _, hostport, _|
-              ports << hostport
-            end
-          end
-        end
-
-        ports
-      end
-
-      def read_vms
-        results = []
-        execute("list", "vms", :retryable => true).split("\n").each do |line|
-          if line =~ /^".+?" \{(.+?)\}$/
-            results << $1.to_s
-          end
-        end
-
-        results
-      end
-
-      def set_mac_address(mac)
-        execute("modifyvm", @uuid, "--macaddress1", mac)
-      end
-
-      def set_name(name)
-        execute("modifyvm", @uuid, "--name", name)
-      end
-
-      def share_folders(folders)
-        folders.each do |folder|
-          args = ["--name",
-                  folder[:name],
-                  "--hostpath",
-                  folder[:hostpath]]
-          args << "--transient" if folder.has_key?(:transient) && folder[:transient]
-          execute("sharedfolder", "add", @uuid, *args)
-        end
-      end
-
-      def ssh_port(expected_port)
-        @logger.debug("Searching for SSH port: #{expected_port.inspect}")
-
-        # Look for the forwarded port only by comparing the guest port
-        read_forwarded_ports.each do |_, _, hostport, guestport|
-          return hostport if guestport == expected_port
-        end
-
-        nil
-      end
-
-      def start(mode)
-        command = ["startvm", @uuid, "--type", mode.to_s]
-        r = raw(*command)
-
-        if r.exit_code == 0 || r.stdout =~ /VM ".+?" has been successfully started/
-          # Some systems return an exit code 1 for some reason. For that
-          # we depend on the output.
-          return true
-        end
-
-        # If we reached this point then it didn't work out.
-        raise Errors::VBoxManageError, :command => command.inspect
-      end
-
-      def suspend
-        execute("controlvm", @uuid, "savestate")
-      end
-
-      def verify!
-        # This command sometimes fails if kernel drivers aren't properly loaded
-        # so we just run the command and verify that it succeeded.
-        execute("list", "hostonlyifs")
-      end
-
-      def verify_image(path)
-        r = raw("import", path.to_s, "--dry-run")
-        return r.exit_code == 0
-      end
-
-      def vm_exists?(uuid)
-        raw("showvminfo", uuid).exit_code == 0
-      end
-    end
-  end
-end