vagrant 1.0.3 → 1.0.4

data/CHANGELOG.md

@@ -1,3 +1,13 @@
+## 1.0.4 (September 13, 2012)
+
+  - VirtualBox 4.2 driver. [GH-1120]
+  - Correct `ssh-config` help to use `--host`, not `-h`.
+  - Use "127.0.0.1" instead of "localhost" for port checking to fix problem
+    where "localhost" is not properly setup. [GH-1057]
+  - Disable read timeout on Net::HTTP to avoid `rbuf_fill` error. [GH-1072]
+  - Retry SSH on `EHOSTUNREACH` errors.
+  - Add missing translation for "saving" state. [GH-1110]
+
 ## 1.0.3 (May 1, 2012)
 
   - Don't enable NAT DNS proxy on machines where resolv.conf already points

data/lib/vagrant/action/vm/check_port_collisions.rb

@@ -33,7 +33,7 @@ module Vagrant
             hostport = options[:hostport].to_i
             hostport = current[options[:name]] if current.has_key?(options[:name])
 
-            if existing.include?(hostport) || is_port_open?("localhost", hostport)
+            if existing.include?(hostport) || is_port_open?("127.0.0.1", hostport)
               # We have a collision! Handle it
               send("handle_#{handler}".to_sym, options, existing)
             end

data/lib/vagrant/action/vm/network.rb

@@ -135,7 +135,7 @@ module Vagrant
 
           # Make a first pass to assign interface numbers by adapter location
           vm_adapters = @env[:vm].driver.read_network_interfaces
-          vm_adapters.each do |number, adapter|
+          vm_adapters.sort.each do |number, adapter|
             if adapter[:type] != :none
               # Not used, so assign the interface number and increment
               adapter_to_interface[number] = current

data/lib/vagrant/command/ssh_config.rb

@@ -11,11 +11,11 @@ module Vagrant
         options = {}
 
         opts = OptionParser.new do |opts|
-          opts.banner = "Usage: vagrant ssh-config [vm-name] [-h name]"
+          opts.banner = "Usage: vagrant ssh-config [vm-name] [--host name]"
 
           opts.separator ""
 
-          opts.on("--host COMMAND", "Name the host for the config..") do |h|
+          opts.on("--host NAME", "Name the host for the config..") do |h|
             options[:host] = h
           end
         end

data/lib/vagrant/communication/ssh.rb

@@ -131,8 +131,17 @@ module Vagrant
         # Connect to SSH, giving it a few tries
         connection = nil
         begin
+          # These are the exceptions that we retry because they represent
+          # errors that are generally fixed from a retry and don't
+          # necessarily represent immediate failure cases.
+          exceptions = [
+            Errno::ECONNREFUSED,
+            Errno::EHOSTUNREACH,
+            Net::SSH::Disconnect,
+            Timeout::Error
+          ]
+
           @logger.info("Connecting to SSH: #{ssh_info[:host]}:#{ssh_info[:port]}")
-          exceptions = [Errno::ECONNREFUSED, Net::SSH::Disconnect]
           connection = retryable(:tries => @vm.config.ssh.max_tries, :on => exceptions) do
             Net::SSH.start(ssh_info[:host], ssh_info[:username], opts)
           end

data/lib/vagrant/downloaders/http.rb

@@ -19,6 +19,7 @@ module Vagrant
         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

data/lib/vagrant/driver.rb

@@ -3,5 +3,6 @@ module Vagrant
     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

@@ -44,7 +44,8 @@ module Vagrant
         @logger.debug("Finding driver for VirtualBox version: #{@version}")
         driver_map   = {
           "4.0" => VirtualBox_4_0,
-          "4.1" => VirtualBox_4_1
+          "4.1" => VirtualBox_4_1,
+          "4.2" => VirtualBox_4_2
         }
 
         driver_klass = nil

data/lib/vagrant/driver/virtualbox_4_2.rb

@@ -0,0 +1,459 @@
+require 'log4r'
+
+require 'vagrant/driver/virtualbox_base'
+
+module Vagrant
+  module Driver
+    # Driver for VirtualBox 4.2.x
+    class VirtualBox_4_2 < VirtualBoxBase
+      def initialize(uuid)
+        super()
+
+        @logger = Log4r::Logger.new("vagrant::driver::virtualbox_4_2")
+        @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

data/lib/vagrant/version.rb

@@ -2,5 +2,5 @@ module Vagrant
   # This will always be up to date with the current version of Vagrant,
   # since it is used to generate the gemspec and is also the source of
   # the version for `vagrant -v`
-  VERSION = "1.0.3"
+  VERSION = "1.0.4"
 end

data/templates/locales/en.yml

@@ -299,6 +299,10 @@ en:
           shut it down forcefully, or you can run `vagrant suspend` to simply
           suspend the virtual machine. In either case, to restart it again,
           simply run `vagrant up`.
+        saving: |-
+          The VM is currently saving its state. In a few moments this state
+          should transition to "saved." Please run `vagrant status` again
+          in a few seconds.
         saved: |-
           To resume this VM, simply run `vagrant up`.
         stuck: |-

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: vagrant
 version: !ruby/object:Gem::Version 
-  hash: 17
+  hash: 31
   prerelease: 
   segments: 
   - 1
   - 0
-  - 3
-  version: 1.0.3
+  - 4
+  version: 1.0.4
 platform: ruby
 authors: 
 - Mitchell Hashimoto
@@ -16,12 +16,11 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2012-05-02 00:00:00 Z
+date: 2012-09-14 00:00:00 Z
 dependencies: 
 - !ruby/object:Gem::Dependency 
   name: archive-tar-minitar
   prerelease: false
-  type: :runtime
   requirement: &id001 !ruby/object:Gem::Requirement 
     none: false
     requirements: 
@@ -33,11 +32,11 @@ dependencies:
         - 5
         - 2
         version: 0.5.2
+  type: :runtime
   version_requirements: *id001
 - !ruby/object:Gem::Dependency 
   name: childprocess
   prerelease: false
-  type: :runtime
   requirement: &id002 !ruby/object:Gem::Requirement 
     none: false
     requirements: 
@@ -49,11 +48,11 @@ dependencies:
         - 3
         - 1
         version: 0.3.1
+  type: :runtime
   version_requirements: *id002
 - !ruby/object:Gem::Dependency 
   name: erubis
   prerelease: false
-  type: :runtime
   requirement: &id003 !ruby/object:Gem::Requirement 
     none: false
     requirements: 
@@ -65,11 +64,11 @@ dependencies:
         - 7
         - 0
         version: 2.7.0
+  type: :runtime
   version_requirements: *id003
 - !ruby/object:Gem::Dependency 
   name: i18n
   prerelease: false
-  type: :runtime
   requirement: &id004 !ruby/object:Gem::Requirement 
     none: false
     requirements: 
@@ -81,11 +80,11 @@ dependencies:
         - 6
         - 0
         version: 0.6.0
+  type: :runtime
   version_requirements: *id004
 - !ruby/object:Gem::Dependency 
   name: json
   prerelease: false
-  type: :runtime
   requirement: &id005 !ruby/object:Gem::Requirement 
     none: false
     requirements: 
@@ -97,11 +96,11 @@ dependencies:
         - 5
         - 1
         version: 1.5.1
+  type: :runtime
   version_requirements: *id005
 - !ruby/object:Gem::Dependency 
   name: log4r
   prerelease: false
-  type: :runtime
   requirement: &id006 !ruby/object:Gem::Requirement 
     none: false
     requirements: 
@@ -113,11 +112,11 @@ dependencies:
         - 1
         - 9
         version: 1.1.9
+  type: :runtime
   version_requirements: *id006
 - !ruby/object:Gem::Dependency 
   name: net-ssh
   prerelease: false
-  type: :runtime
   requirement: &id007 !ruby/object:Gem::Requirement 
     none: false
     requirements: 
@@ -129,11 +128,11 @@ dependencies:
         - 2
         - 2
         version: 2.2.2
+  type: :runtime
   version_requirements: *id007
 - !ruby/object:Gem::Dependency 
   name: net-scp
   prerelease: false
-  type: :runtime
   requirement: &id008 !ruby/object:Gem::Requirement 
     none: false
     requirements: 
@@ -145,11 +144,11 @@ dependencies:
         - 0
         - 4
         version: 1.0.4
+  type: :runtime
   version_requirements: *id008
 - !ruby/object:Gem::Dependency 
   name: rake
   prerelease: false
-  type: :development
   requirement: &id009 !ruby/object:Gem::Requirement 
     none: false
     requirements: 
@@ -159,11 +158,11 @@ dependencies:
         segments: 
         - 0
         version: "0"
+  type: :development
   version_requirements: *id009
 - !ruby/object:Gem::Dependency 
   name: contest
   prerelease: false
-  type: :development
   requirement: &id010 !ruby/object:Gem::Requirement 
     none: false
     requirements: 
@@ -175,11 +174,11 @@ dependencies:
         - 1
         - 2
         version: 0.1.2
+  type: :development
   version_requirements: *id010
 - !ruby/object:Gem::Dependency 
   name: minitest
   prerelease: false
-  type: :development
   requirement: &id011 !ruby/object:Gem::Requirement 
     none: false
     requirements: 
@@ -191,11 +190,11 @@ dependencies:
         - 5
         - 1
         version: 2.5.1
+  type: :development
   version_requirements: *id011
 - !ruby/object:Gem::Dependency 
   name: mocha
   prerelease: false
-  type: :development
   requirement: &id012 !ruby/object:Gem::Requirement 
     none: false
     requirements: 
@@ -205,11 +204,11 @@ dependencies:
         segments: 
         - 0
         version: "0"
+  type: :development
   version_requirements: *id012
 - !ruby/object:Gem::Dependency 
   name: rspec-core
   prerelease: false
-  type: :development
   requirement: &id013 !ruby/object:Gem::Requirement 
     none: false
     requirements: 
@@ -221,11 +220,11 @@ dependencies:
         - 8
         - 0
         version: 2.8.0
+  type: :development
   version_requirements: *id013
 - !ruby/object:Gem::Dependency 
   name: rspec-expectations
   prerelease: false
-  type: :development
   requirement: &id014 !ruby/object:Gem::Requirement 
     none: false
     requirements: 
@@ -237,11 +236,11 @@ dependencies:
         - 8
         - 0
         version: 2.8.0
+  type: :development
   version_requirements: *id014
 - !ruby/object:Gem::Dependency 
   name: rspec-mocks
   prerelease: false
-  type: :development
   requirement: &id015 !ruby/object:Gem::Requirement 
     none: false
     requirements: 
@@ -253,6 +252,7 @@ dependencies:
         - 8
         - 0
         version: 2.8.0
+  type: :development
   version_requirements: *id015
 description: Vagrant is a tool for building and distributing virtualized development environments.
 email: 
@@ -377,6 +377,7 @@ files:
 - lib/vagrant/driver/virtualbox.rb
 - lib/vagrant/driver/virtualbox_4_0.rb
 - lib/vagrant/driver/virtualbox_4_1.rb
+- lib/vagrant/driver/virtualbox_4_2.rb
 - lib/vagrant/driver/virtualbox_base.rb
 - lib/vagrant/environment.rb
 - lib/vagrant/errors.rb
@@ -707,7 +708,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
 requirements: []
 
 rubyforge_project: vagrant
-rubygems_version: 1.8.6
+rubygems_version: 1.8.24
 signing_key: 
 specification_version: 3
 summary: Build and distribute virtualized development environments.