vagrantup 0.8.7 → 0.8.8

data/lib/vagrant/provisioners/chef_client.rb

@@ -26,7 +26,7 @@ module Vagrant
           @file_cache_path = "/srv/chef/file_store"
           @file_backup_path = "/srv/chef/cache"
           @encrypted_data_bag_secret_key_path = nil
-          @encrypted_data_bag_secret = "/etc/chef/encrypted_data_bag_secret"
+          @encrypted_data_bag_secret = "/tmp/encrypted_data_bag_secret"
         end
 
         def validate(errors)

data/lib/vagrant/provisioners/chef_solo.rb

@@ -36,9 +36,9 @@ module Vagrant
       attr_reader :data_bags_folders
 
       def prepare
-        @cookbook_folders = expanded_folders(config.cookbooks_path)
-        @role_folders = expanded_folders(config.roles_path)
-        @data_bags_folders = expanded_folders(config.data_bags_path)
+        @cookbook_folders = expanded_folders(config.cookbooks_path, "cookbooks")
+        @role_folders = expanded_folders(config.roles_path, "roles")
+        @data_bags_folders = expanded_folders(config.data_bags_path, "data_bags")
 
         share_folders("csc", @cookbook_folders)
         share_folders("csr", @role_folders)
@@ -54,7 +54,7 @@ module Vagrant
       end
 
       # Converts paths to a list of properly expanded paths with types.
-      def expanded_folders(paths)
+      def expanded_folders(paths, appended_folder=nil)
         return [] if paths.nil?
 
         # Convert the path to an array if it is a string or just a single
@@ -77,8 +77,17 @@ module Vagrant
             # Path already exists on the virtual machine. Expand it
             # relative to where we're provisioning.
             remote_path = File.expand_path(path, config.provisioning_path)
+
+            # Remove drive letter if running on a windows host. This is a bit
+            # of a hack but is the most portable way I can think of at the moment
+            # to achieve this. Otherwise, Vagrant attempts to share at some crazy
+            # path like /home/vagrant/c:/foo/bar
+            remote_path = remote_path.gsub(/^[a-zA-Z]:/, "")
           end
 
+          # If we have specified a folder name to append then append it
+          remote_path += "/#{appended_folder}" if appended_folder
+
           # Return the result
           [type, local_path, remote_path]
         end

data/lib/vagrant/ssh.rb

@@ -19,7 +19,6 @@ module Vagrant
 
     def initialize(environment)
       @env = environment
-      @current_session = nil
     end
 
     # Connects to the environment's virtual machine, replacing the ruby
@@ -53,9 +52,6 @@ module Vagrant
         command_options << "-o ForwardX11Trusted=yes"
       end
 
-      # Some hackery going on here. On Mac OS X Leopard (10.5), exec fails
-      # (GH-51). As a workaround, we fork and wait. On all other platforms,
-      # we simply exec.
       command = "ssh #{command_options.join(" ")} #{options[:username]}@#{options[:host]}".strip
       env.logger.info("ssh") { "Invoking SSH: #{command}" }
       safe_exec(command)
@@ -72,47 +68,22 @@ module Vagrant
       opts[:forward_agent] = true if env.config.ssh.forward_agent
       opts[:port] ||= port
 
-      # Check if we have a currently open SSH session which has the
-      # same options, and use that if possible.
-      #
-      # NOTE: This is experimental and unstable. Therefore it is disabled
-      # by default.
-      session, options = nil
-      session, options = @current_session if env.config.vagrant.ssh_session_cache
-
-      if session && options == opts
-        # Verify that the SSH session is still valid
-        begin
-          session.exec!("echo foo")
-        rescue IOError
-          # Reset the session, we need to reconnect
-          session = nil
-        end
-      end
-
-      if !session || options != opts
-        env.logger.info("ssh") { "Connecting to SSH: #{env.config.ssh.host} #{opts[:port]}" }
-
-        # The exceptions which are acceptable to retry on during
-        # attempts to connect to SSH
-        exceptions = [Errno::ECONNREFUSED, Net::SSH::Disconnect]
-
-        # Connect to SSH and gather the session
-        session = retryable(:tries => 5, :on => exceptions) do
-          connection = Net::SSH.start(env.config.ssh.host,
-                         env.config.ssh.username,
-                         opts.merge( :keys => [env.config.ssh.private_key_path],
-                                     :keys_only => true,
-                                     :user_known_hosts_file => [],
-                                     :paranoid => false,
-                                     :config => false))
-          SSH::Session.new(connection, env)
-        end
-
-        # Save the new session along with the options which created it
-        @current_session = [session, opts]
-      else
-        env.logger.info("ssh") { "Using cached SSH session: #{session}" }
+      env.logger.info("ssh") { "Connecting to SSH: #{env.config.ssh.host} #{opts[:port]}" }
+
+      # The exceptions which are acceptable to retry on during
+      # attempts to connect to SSH
+      exceptions = [Errno::ECONNREFUSED, Net::SSH::Disconnect]
+
+      # Connect to SSH and gather the session
+      session = retryable(:tries => env.config.ssh.max_tries, :on => exceptions) do
+        connection = Net::SSH.start(env.config.ssh.host,
+                                    env.config.ssh.username,
+                                    opts.merge( :keys => [env.config.ssh.private_key_path],
+                                                :keys_only => true,
+                                                :user_known_hosts_file => [],
+                                                :paranoid => false,
+                                                :config => false))
+        SSH::Session.new(connection, env)
       end
 
       # Yield our session for executing
@@ -144,15 +115,19 @@ module Vagrant
 
       require 'timeout'
       Timeout.timeout(env.config.ssh.timeout) do
-        execute(:timeout => env.config.ssh.timeout,
-                :port => ssh_port) { |ssh| }
+        execute(:timeout => env.config.ssh.timeout, :port => ssh_port) do |ssh|
+          # We run a basic command to test that the shell is up and
+          # ready to receive commands. Only then is our SSH connection
+          # truly "up"
+          return ssh.exec!("echo hello") == "hello\n"
+        end
       end
 
-      true
+      false
     rescue Net::SSH::AuthenticationFailed
       raise Errors::SSHAuthenticationFailed
     rescue Timeout::Error, Errno::ECONNREFUSED, Net::SSH::Disconnect,
-           Errors::SSHConnectionRefused, Net::SSH::AuthenticationFailed
+           Errors::SSHConnectionRefused
       return false
     end
 

data/lib/vagrant/ssh/session.rb

@@ -61,7 +61,7 @@ module Vagrant
       # the actual `exec!` implementation, except that this
       # implementation also reports `:exit_status` to the block if given.
       def exec!(commands, options=nil, &block)
-        retryable(:tries => 5, :on => [IOError, Net::SSH::Disconnect], :sleep => 1.0) do
+        retryable(:tries => env.config.ssh.max_tries, :on => [IOError, Net::SSH::Disconnect], :sleep => 1.0) do
           metach = session.open_channel do |ch|
             ch.exec("#{env.config.ssh.shell} -l") do |ch2, success|
               # Set the terminal

data/lib/vagrant/systems/solaris.rb

@@ -15,11 +15,13 @@ module Vagrant
         attr_accessor :halt_check_interval
         # This sets the command to use to execute items as a superuser. sudo is default
         attr_accessor :suexec_cmd
+        attr_accessor :device
 
         def initialize
           @halt_timeout = 30
           @halt_check_interval = 1
           @suexec_cmd = 'sudo'
+          @device = "e1000g"
         end
       end
 
@@ -28,6 +30,33 @@ module Vagrant
         error_namespace("vagrant.systems.solaris")
       end
 
+      def prepare_host_only_network(net_options=nil)
+      end
+
+      def enable_host_only_network(net_options)
+        device = "#{vm.env.config.solaris.device}#{net_options[:adapter]}"
+        su_cmd = vm.env.config.solaris.suexec_cmd
+        ifconfig_cmd = "#{su_cmd} /sbin/ifconfig #{device}"
+        vm.ssh.execute do |ssh|
+          ssh.exec!("#{ifconfig_cmd} plumb")
+          ssh.exec!("#{ifconfig_cmd} inet #{net_options[:ip]} netmask #{net_options[:netmask]}")
+          ssh.exec!("#{ifconfig_cmd} up")
+          ssh.exec!("#{su_cmd} sh -c \"echo '#{net_options[:ip]}' > /etc/hostname.#{device}\"")
+        end
+      end
+
+      def change_host_name(name)
+        su_cmd = vm.env.config.solaris.suexec_cmd
+        vm.ssh.execute do |ssh|
+          # Only do this if the hostname is not already set
+          if !ssh.test?("#{su_cmd} hostname | grep '#{name}'")
+            ssh.exec!("#{su_cmd} sh -c \"echo '#{name}' > /etc/nodename\"")
+            ssh.exec!("#{su_cmd} uname -S #{name}")
+          end
+        end
+      end
+
+
       # There should be an exception raised if the line
       #
       #     vagrant::::profiles=Primary Administrator
@@ -36,19 +65,36 @@ module Vagrant
       def halt
         vm.env.ui.info I18n.t("vagrant.systems.solaris.attempting_halt")
         vm.ssh.execute do |ssh|
-          ssh.exec!("#{vm.env.config.solaris.suexec_cmd} /usr/sbin/poweroff")
-        end
+          # Wait until the VM's state is actually powered off. If this doesn't
+          # occur within a reasonable amount of time (15 seconds by default),
+          # then simply return and allow Vagrant to kill the machine.
+          count = 0
+          last_error = nil
+          while vm.vm.state != :powered_off
+            begin
+              ssh.exec!("#{vm.env.config.solaris.suexec_cmd} /usr/sbin/poweroff")
+            rescue IOError => e
+              # Save the last error; if it's not shutdown in a reasonable amount
+              # of attempts we will re-raise the error so it's not hidden for
+              # all time
+              last_error = e
+            end
 
-        # Wait until the VM's state is actually powered off. If this doesn't
-        # occur within a reasonable amount of time (15 seconds by default),
-        # then simply return and allow Vagrant to kill the machine.
-        count = 0
-        while vm.vm.state != :powered_off
-          count += 1
+            count += 1
+            if count >= vm.env.config.solaris.halt_timeout
+              # Check for last error and re-raise it
+              if last_error != nil
+                raise last_error
+              else
+                # Otherwise, just return
+                return
+              end
+            end
 
-          return if count >= vm.env.config.solaris.halt_timeout
-          sleep vm.env.config.solaris.halt_check_interval
-        end
+            # Still opportunities remaining; sleep and loop
+            sleep vm.env.config.solaris.halt_check_interval
+          end # while
+        end # do
       end
 
       def mount_shared_folder(ssh, name, guestpath, owner, group)

data/lib/vagrant/test_helpers.rb

@@ -84,6 +84,29 @@ module Vagrant
       [app, env]
     end
 
+    # Utility method for capturing output streams.
+    # @example Evaluate the output
+    #   output = capture(:stdout){ env.cli("foo") }
+    #   assert_equal "bar", output
+    # @example Silence the output
+    #   silence(:stdout){ env.cli("init") }
+    # @param [:stdout, :stderr] stream The stream to capture
+    # @yieldreturn String
+    # @see https://github.com/wycats/thor/blob/master/spec/spec_helper.rb
+    def capture(stream)
+      begin
+        stream = stream.to_s
+        eval "$#{stream} = StringIO.new"
+        yield
+        result = eval("$#{stream}").string
+      ensure
+        eval("$#{stream} = #{stream.upcase}")
+      end
+
+      result
+    end
+    alias :silence :capture
+
     #------------------------------------------------------------
     # Path helpers
     #------------------------------------------------------------

data/lib/vagrant/ui.rb

@@ -10,7 +10,7 @@ module Vagrant
     end
 
     [:warn, :error, :info, :confirm].each do |method|
-      define_method(method) do |message|
+      define_method(method) do |message, *opts|
         # Log normal console messages
         env.logger.info("ui") { message }
       end

data/lib/vagrant/util.rb

@@ -2,7 +2,6 @@ module Vagrant
   module Util
     autoload :Busy,                      'vagrant/util/busy'
     autoload :Counter,                   'vagrant/util/counter'
-    autoload :GlobLoader,                'vagrant/util/glob_loader'
     autoload :HashWithIndifferentAccess, 'vagrant/util/hash_with_indifferent_access'
     autoload :Platform,                  'vagrant/util/platform'
     autoload :Retryable,                 'vagrant/util/retryable'

data/lib/vagrant/util/file_checksum.rb

@@ -0,0 +1,38 @@
+# This is an "interface" that should be implemented by any digest class
+# passed into FileChecksum. Note that this isn't strictly enforced at
+# the moment, and this class isn't directly used. It is merely here for
+# documentation of structure of the class.
+class DigestClass
+  def update(string); end
+  def hexdigest; end
+end
+
+class FileChecksum
+  BUFFER_SIZE = 1024
+
+  # Initializes an object to calculate the checksum of a file. The given
+  # ``digest_klass`` should implement the ``DigestClass`` interface. Note
+  # that the built-in Ruby digest classes duck type this properly:
+  # Digest::MD5, Digest::SHA1, etc.
+  def initialize(path, digest_klass)
+    @digest_klass = digest_klass
+    @path   = path
+  end
+
+  # This calculates the checksum of the file and returns it as a
+  # string.
+  #
+  # @return [String]
+  def checksum
+    digest= @digest_klass.new
+
+    File.open(@path, "r") do |f|
+      while !f.eof
+        buf = f.readpartial(BUFFER_SIZE)
+        digest.update(buf)
+      end
+    end
+
+    return digest.hexdigest
+  end
+end

data/lib/vagrant/util/platform.rb

@@ -13,7 +13,7 @@ module Vagrant
           platform.include?("darwin9")
         end
 
-        [:darwin, :bsd, :linux].each do |type|
+        [:darwin, :bsd, :freebsd, :linux].each do |type|
           define_method("#{type}?") do
             platform.include?(type.to_s)
           end

data/lib/vagrant/util/safe_exec.rb

@@ -2,7 +2,7 @@ module Vagrant
   module Util
     # This module provies a `safe_exec` method which is a drop-in
     # replacement for `Kernel.exec` which addresses a specific issue
-    # which manifests on OS X 10.5 and perhaps other operating systems.
+    # which manifests on OS X 10.5 (GH-51) and perhaps other operating systems.
     # This issue causes `exec` to fail if there is more than one system
     # thread. In that case, `safe_exec` automatically falls back to
     # forking.
@@ -14,6 +14,7 @@ module Vagrant
         rescue_from = []
         rescue_from << Errno::EOPNOTSUPP if defined?(Errno::EOPNOTSUPP)
         rescue_from << Errno::E045 if defined?(Errno::E045)
+        rescue_from << SystemCallError
 
         fork_instead = false
         begin

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 = "0.8.7"
+  VERSION = "0.8.8"
 end

data/tasks/acceptance.rake

@@ -0,0 +1,113 @@
+require 'digest/sha1'
+require 'net/http'
+require 'pathname'
+require 'uri'
+require 'yaml'
+
+require 'childprocess'
+
+require 'vagrant/util/file_checksum'
+
+namespace :acceptance do
+  desc "Downloads the boxes required for running the acceptance tests."
+  task :boxes, :directory do |t, args|
+    # Create the directory where the boxes will be downloaded
+    box_dir = Pathname.new(args[:directory] || File.expand_path("../../test/tmp/boxes", __FILE__))
+    box_dir.mkpath
+    puts "Boxes will be placed in: #{box_dir}"
+
+    # Load the required boxes
+    boxes = YAML.load_file(File.expand_path("../../test/config/acceptance_boxes.yml", __FILE__))
+
+    boxes.each do |box|
+      puts "Box: #{box["name"]}"
+      box_file = box_dir.join("#{box["name"]}.box")
+      checksum = FileChecksum.new(box_file, Digest::SHA1)
+
+      # If the box exists, we need to check the checksum and determine if we need
+      # to redownload the file.
+      if box_file.exist?
+        print "Box exists, checking SHA1 sum... "
+        if checksum.checksum == box["checksum"]
+          print "OK\n"
+          next
+        else
+          print "FAIL\n"
+        end
+      end
+
+      # Download the file. Note that this has no error checking and just uses
+      # pure net/http. There could be a better way.
+      puts "Downloading: #{box["url"]}"
+      destination = box_file.open("wb")
+      uri = URI.parse(box["url"])
+      Net::HTTP.new(uri.host, uri.port).start do |http|
+        http.request_get(uri.request_uri) do |response|
+          total = response.content_length
+          progress = 0
+          count = 0
+
+          response.read_body do |segment|
+            # Really elementary progress meter
+            progress += segment.length
+            count += 1
+            puts "Progress: #{(progress.to_f / total.to_f) * 100}%" if count % 300 == 0
+
+            # Write out to the destination file
+            destination.write(segment)
+          end
+        end
+      end
+
+      destination.close
+
+      # Check the checksum of the new file to verify that it
+      # downloaded properly. This shouldn't happen, but it can!
+      if checksum.checksum != box["checksum"]
+        puts "Checksum didn't match! Download was corrupt!"
+        abort
+      end
+    end
+  end
+
+  desc "Generates the configuration for acceptance tests from current source."
+  task :config, :box_dir do |t, args|
+    require File.expand_path("../../lib/vagrant/version", __FILE__)
+    require File.expand_path('../../test/acceptance/support/tempdir', __FILE__)
+
+    # Get the directory for the boxes
+    box_dir = Pathname.new(args[:box_dir] || File.expand_path("../../test/tmp/boxes", __FILE__))
+
+    # Generate the binstubs for the Vagrant binary
+    tempdir = Tempdir.new
+    process = ChildProcess.build("bundle", "install", "--binstubs", tempdir.path)
+    process.io.inherit!
+    process.start
+    process.poll_for_exit(64000)
+    if process.exit_code != 0
+      # Bundle install failed...
+      puts "Bundle install failed!"
+      abort
+    end
+
+    # Generate the actual configuration
+    config = {
+      "vagrant_path" => File.join(tempdir.path, "vagrant"),
+      "vagrant_version" => Vagrant::VERSION,
+      "env" => {
+        "BUNDLE_GEMFILE" => File.expand_path("../../Gemfile", __FILE__)
+      },
+      "box_directory" => box_dir.to_s
+    }
+
+    File.open("acceptance_config.yml", "w+") do |f|
+      f.write(YAML.dump(config))
+    end
+
+    puts <<-OUTPUT
+Acceptance test configuration is now in this directory in
+"acceptance_config.yml." Set your ACCEPTANCE_CONFIG environmental
+variable to this file and run any of the acceptance tests now.
+OUTPUT
+  end
+end