vagrantup 0.8.10 → 0.9.0

data/lib/vagrant/data_store.rb

@@ -1,3 +1,7 @@
+require 'pathname'
+
+require 'log4r'
+
 module Vagrant
   # The Vagrant data store is a key-value store which is persisted
   # as JSON in a local file which is specified in the initializer.
@@ -16,19 +20,19 @@ module Vagrant
     attr_reader :file_path
 
     def initialize(file_path)
-      @file_path = file_path
-      return if !file_path
+      @logger    = Log4r::Logger.new("vagrant::datastore")
+      @logger.info("Created: #{file_path}")
+
+      @file_path = Pathname.new(file_path)
 
-      raise Errors::DotfileIsDirectory if File.directory?(file_path)
+      if @file_path.exist?
+        raise Errors::DotfileIsDirectory if @file_path.directory?
 
-      if File.exist?(file_path)
-        File.open(file_path, "r") do |f|
-          begin
-            merge!(JSON.parse(f.read))
-          rescue JSON::ParserError
-            # Ignore if the data is invalid in the file.
-            # TODO: Log here.
-          end
+        begin
+          merge!(JSON.parse(@file_path.read))
+        rescue JSON::ParserError
+          # Ignore if the data is invalid in the file.
+          @logger.error("Data store contained invalid JSON. Ignoring.")
         end
       end
     end
@@ -36,15 +40,19 @@ module Vagrant
     # Commits any changes to the data to disk. Even if the data
     # hasn't changed, it will be reserialized and written to disk.
     def commit
-      return if !file_path
-
       clean_nil_and_empties
 
       if empty?
         # Delete the file since an empty data store is not useful
-        File.delete(file_path) if File.file?(file_path)
+        @logger.info("Deleting data store since we're empty: #{@file_path}")
+        @file_path.delete if @file_path.exist?
       else
-        File.open(file_path, "w") { |f| f.write(to_json) }
+        @logger.info("Committing data to data store: #{@file_path}")
+
+        @file_path.open("w") do |f|
+          f.write(to_json)
+          f.fsync
+        end
       end
     end
 

data/lib/vagrant/downloaders/base.rb

@@ -5,13 +5,15 @@ module Vagrant
     class Base
       include Vagrant::Util
 
-      # The environment which this downloader is operating.
-      attr_reader :env
-
-      def initialize(env)
-        @env = env
+      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
 

data/lib/vagrant/downloaders/file.rb

@@ -6,16 +6,16 @@ module Vagrant
     # simply does a file copy.
     class File < Base
       def self.match?(uri)
-        ::File.exists?(uri)
+        ::File.file?(::File.expand_path(uri))
       end
 
       def prepare(source_url)
-        raise Errors::DownloaderFileDoesntExist if !::File.file?(source_url)
+        raise Errors::DownloaderFileDoesntExist if !::File.file?(::File.expand_path(source_url))
       end
 
       def download!(source_url, destination_file)
-        env.ui.info I18n.t("vagrant.downloaders.file.download")
-        FileUtils.cp(source_url, destination_file.path)
+        @ui.info I18n.t("vagrant.downloaders.file.download")
+        FileUtils.cp(::File.expand_path(source_url), destination_file.path)
       end
     end
   end

data/lib/vagrant/downloaders/http.rb

@@ -1,6 +1,5 @@
 require 'net/http'
 require 'net/https'
-require 'open-uri'
 require 'uri'
 require 'base64'
 
@@ -27,7 +26,7 @@ module Vagrant
         end
 
         http.start do |h|
-          env.ui.info I18n.t("vagrant.downloaders.http.download", :url => source_url)
+          @ui.info I18n.t("vagrant.downloaders.http.download", :url => source_url)
 
           headers = nil
           if uri.user && uri.password
@@ -56,8 +55,8 @@ module Vagrant
               # Progress reporting is limited to every 25 segments just so
               # we're not constantly updating
               if segment_count % 25 == 0
-                env.ui.clear_line
-                env.ui.report_progress(progress, total)
+                @ui.clear_line
+                @ui.report_progress(progress, total)
                 segment_count = 0
               end
 
@@ -66,7 +65,7 @@ module Vagrant
             end
 
             # Clear the line one last time so that the progress meter disappears
-            env.ui.clear_line
+            @ui.clear_line
           end
         end
       rescue SocketError

data/lib/vagrant/driver/virtualbox.rb

@@ -0,0 +1,121 @@
+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)
+        # 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
+        }
+
+        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,
+                               :share_folders,
+                               :ssh_port,
+                               :start,
+                               :suspend,
+                               :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:
+        execute("--version").split("_")[0].split("r")[0]
+      end
+    end
+  end
+end

data/lib/vagrant/driver/virtualbox_4_0.rb

@@ -0,0 +1,411 @@
+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_1")
+        @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
+        execute("showvminfo", @uuid, "--machinereadable").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+\{(.+?)\}$/
+            execute("showvminfo", $1.to_s, "--machinereadable").split("\n").each do |info|
+              if info =~ /^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
+        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)
+      end
+
+      def halt
+        execute("controlvm", @uuid, "poweroff")
+      end
+
+      def import(ovf, name)
+        total = ""
+        last  = 0
+        execute("import", ovf, "--vsys", "0", "--vmname", name) do |type, data|
+          if 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
+
+        output = execute("list", "vms")
+        if output =~ /^"#{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
+        execute("showvminfo", uuid, "--machinereadable").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")
+        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").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").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
+            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
+        execute("showvminfo", @uuid, "--machinereadable").split("\n").each do |line|
+          return $1.to_s if line =~ /^macaddress1="(.+?)"$/
+        end
+
+        nil
+      end
+
+      def read_machine_folder
+        execute("list", "systemproperties").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 = {}
+        execute("showvminfo", @uuid, "--machinereadable").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")
+        if output =~ /^name="<inaccessible>"$/
+          return :inaccessible
+        elsif output =~ /^VMState="(.+?)"$/
+          return $1.to_sym
+        end
+
+        nil
+      end
+
+      def read_used_ports
+        ports = []
+        execute("list", "vms").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").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 share_folders(folders)
+        folders.each do |folder|
+          execute("sharedfolder", "add", @uuid, "--name",
+                  folder[:name], "--hostpath", folder[:hostpath])
+        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)
+        execute("startvm", @uuid, "--type", mode.to_s)
+      end
+
+      def suspend
+        execute("controlvm", @uuid, "savestate")
+      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