vagrant 0.2.0 → 0.3.0

data/lib/vagrant/provisioners/chef_solo.rb

@@ -4,6 +4,7 @@ module Vagrant
     class ChefSolo < Chef
       def prepare
         share_cookbook_folders
+        share_role_folders
       end
 
       def provision!
@@ -15,24 +16,28 @@ module Vagrant
 
       def share_cookbook_folders
         host_cookbook_paths.each_with_index do |cookbook, i|
-          Vagrant.config.vm.share_folder("vagrant-chef-solo-#{i}", cookbook_path(i), cookbook)
+          env.config.vm.share_folder("v-csc-#{i}", cookbook_path(i), cookbook)
         end
       end
 
-      def setup_solo_config
-        solo_file = <<-solo
-file_cache_path "#{Vagrant.config.chef.provisioning_path}"
-cookbook_path #{cookbooks_path}
-solo
+      def share_role_folders
+        host_role_paths.each_with_index do |role, i|
+          env.config.vm.share_folder("v-csr-#{i}", role_path(i), role)
+        end
+      end
 
-        logger.info "Uploading chef-solo configuration script..."
-        SSH.upload!(StringIO.new(solo_file), File.join(Vagrant.config.chef.provisioning_path, "solo.rb"))
+      def setup_solo_config
+        setup_config("chef_solo_solo", "solo.rb", {
+          :provisioning_path => env.config.chef.provisioning_path,
+          :cookbooks_path => cookbooks_path,
+          :roles_path => roles_path
+        })
       end
 
       def run_chef_solo
         logger.info "Running chef-solo..."
-        SSH.execute do |ssh|
-          ssh.exec!("cd #{Vagrant.config.chef.provisioning_path} && sudo chef-solo -c solo.rb -j dna.json") do |channel, data, stream|
+        env.ssh.execute do |ssh|
+          ssh.exec!("cd #{env.config.chef.provisioning_path} && sudo chef-solo -c solo.rb -j dna.json") do |channel, data, stream|
             # TODO: Very verbose. It would be easier to save the data and only show it during
             # an error, or when verbosity level is set high
             logger.info("#{stream}: #{data}")
@@ -40,28 +45,49 @@ solo
         end
       end
 
-      def host_cookbook_paths
-        cookbooks = Vagrant.config.chef.cookbooks_path
-        cookbooks = [cookbooks] unless cookbooks.is_a?(Array)
-        cookbooks.collect! { |cookbook| File.expand_path(cookbook, Env.root_path) }
-        return cookbooks
+      def host_folder_paths(paths)
+        [paths].flatten.collect { |path| File.expand_path(path, env.root_path) }
       end
 
-      def cookbook_path(i)
-        File.join(Vagrant.config.chef.provisioning_path, "cookbooks-#{i}")
+      def folder_path(folder, i)
+        File.join(env.config.chef.provisioning_path, "#{folder}-#{i}")
       end
 
-      def cookbooks_path
+      def folders_path(folders, folder)
         result = []
-        host_cookbook_paths.each_with_index do |host_path, i|
-          result << cookbook_path(i)
+        folders.each_with_index do |host_path, i|
+          result << folder_path(folder, i)
         end
 
         # We're lucky that ruby's string and array syntax for strings is the
         # same as JSON, so we can just convert to JSON here and use that
-        result = result.to_s if result.length == 1
+        result = result[0].to_s if result.length == 1
         result.to_json
       end
+
+      def host_cookbook_paths
+        host_folder_paths(env.config.chef.cookbooks_path)
+      end
+
+      def host_role_paths
+        host_folder_paths(env.config.chef.roles_path)
+      end
+
+      def cookbook_path(i)
+        folder_path("cookbooks", i)
+      end
+
+      def role_path(i)
+        folder_path("roles", i)
+      end
+
+      def cookbooks_path
+        folders_path(host_cookbook_paths, "cookbooks")
+      end
+
+      def roles_path
+        folders_path(host_role_paths, "roles")
+      end
     end
   end
-end
+end

data/lib/vagrant/ssh.rb

@@ -1,68 +1,117 @@
 module Vagrant
+  # Manages SSH access to a specific environment. Allows an environment to
+  # replace the process with SSH itself, run a specific set of commands,
+  # upload files, or even check if a host is up.
   class SSH
     include Vagrant::Util
 
-    class << self
-      def connect(opts={})
-        options = {}
-        [:host, :username, :private_key_path].each do |param|
-          options[param] = opts[param] || Vagrant.config.ssh.send(param)
-        end
+    # Reference back up to the environment which this SSH object belongs
+    # to
+    attr_accessor :env
+
+    def initialize(environment)
+      @env = environment
+    end
 
-        Kernel.exec "ssh -p #{port(opts)} -o UserKnownHostsFile=/dev/null -o StrictHostKeyChecking=no -i #{options[:private_key_path]} #{options[:username]}@#{options[:host]}".strip
+    # Connects to the environment's virtual machine, replacing the ruby
+    # process with an SSH process. This method optionally takes a hash
+    # of options which override the configuration values.
+    def connect(opts={})
+      if Mario::Platform.windows?
+        error_and_exit(:ssh_unavailable_windows,
+                       :key_path => env.config.ssh.private_key_path,
+                       :ssh_port => port(opts))
       end
 
-      def execute(opts={})
-        Net::SSH.start(Vagrant.config.ssh.host,
-                       Vagrant.config[:ssh][:username],
-                       opts.merge( :port => port,
-                                   :keys => [Vagrant.config.ssh.private_key_path])) do |ssh|
-          yield ssh
-        end
+      options = {}
+      [:host, :username, :private_key_path].each do |param|
+        options[param] = opts[param] || env.config.ssh.send(param)
       end
 
-      def upload!(from, to)
-        execute do |ssh|
-          scp = Net::SCP.new(ssh)
-          scp.upload!(from, to)
-        end
+      check_key_permissions(options[:private_key_path])
+
+      # 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.
+      pid = nil
+      pid = fork if Util::Platform.leopard?
+      Kernel.exec "ssh -p #{port(opts)} -o UserKnownHostsFile=/dev/null -o StrictHostKeyChecking=no -i #{options[:private_key_path]} #{options[:username]}@#{options[:host]}".strip if pid.nil?
+      Process.wait(pid) if pid
+    end
+
+    # Opens an SSH connection to this environment's virtual machine and yields
+    # a Net::SSH object which can be used to execute remote commands.
+    def execute(opts={})
+      Net::SSH.start(env.config.ssh.host,
+                     env.config[:ssh][:username],
+                     opts.merge( :port => port,
+                                 :keys => [env.config.ssh.private_key_path])) do |ssh|
+        yield ssh
+      end
+    end
+
+    # Uploads a file from `from` to `to`. `from` is expected to be a filename
+    # or StringIO, and `to` is expected to be a path. This method simply forwards
+    # the arguments to `Net::SCP#upload!` so view that for more information.
+    def upload!(from, to)
+      execute do |ssh|
+        scp = Net::SCP.new(ssh)
+        scp.upload!(from, to)
       end
+    end
 
-      def up?
-        check_thread = Thread.new do
-          begin
-            Thread.current[:result] = false
-            execute(:timeout => Vagrant.config.ssh.timeout) do |ssh|
-              Thread.current[:result] = true
-            end
-          rescue Errno::ECONNREFUSED, Net::SSH::Disconnect
-            # False, its defaulted above
+    # Checks if this environment's machine is up (i.e. responding to SSH).
+    #
+    # @return [Boolean]
+    def up?
+      check_thread = Thread.new do
+        begin
+          Thread.current[:result] = false
+          execute(:timeout => env.config.ssh.timeout) do |ssh|
+            Thread.current[:result] = true
           end
+        rescue Errno::ECONNREFUSED, Net::SSH::Disconnect
+          # False, its defaulted above
         end
+      end
 
-        check_thread.join(Vagrant.config.ssh.timeout)
-        return check_thread[:result]
-      rescue Net::SSH::AuthenticationFailed
-        error_and_exit(<<-msg)
-SSH authentication failed! While this could be due to a variety of reasons,
-the two most common are: private key path is incorrect or you're using a box
-which was built for Vagrant 0.1.x.
+      check_thread.join(env.config.ssh.timeout)
+      return check_thread[:result]
+    rescue Net::SSH::AuthenticationFailed
+      error_and_exit(:vm_ssh_auth_failed)
+    end
 
-Vagrant 0.2.x dropped support for password-based authentication. If you're
-tring to `vagrant up` a box which does not support Vagrant's private/public
-keypair, then this error will be raised. To resolve this, read the guide
-on converting base boxes from password-based to keypairs here:
+    # Checks the file permissions for the private key, resetting them
+    # if needed, or on failure erroring.
+    def check_key_permissions(key_path)
+      # TODO: This only works on unix based systems for now. Windows
+      # systems will need to be investigated further.
+      stat = File.stat(key_path)
 
-http://vagrantup.com/docs/converting_password_to_key_ssh.html
+      if stat.owned? && file_perms(key_path) != "600"
+        logger.info "Permissions on private key incorrect, fixing..."
+        File.chmod(0600, key_path)
 
-If the box was built for 0.2.x and contains a custom public key, perhaps
-the path to the private key is incorrect. Check your `config.ssh.private_key_path`.
-msg
+        error_and_exit(:ssh_bad_permissions, :key_path => key_path) if file_perms(key_path) != "600"
       end
+    rescue Errno::EPERM
+      # This shouldn't happen since we verify we own the file, but just
+      # in case.
+      error_and_exit(:ssh_bad_permissions, :key_path => key_path)
+    end
 
-      def port(opts={})
-        opts[:port] || Vagrant.config.vm.forwarded_ports[Vagrant.config.ssh.forwarded_port_key][:hostport]
-      end
+    # Returns the file permissions of a given file. This is fairly unix specific
+    # and probably doesn't belong in this class. Will be refactored out later.
+    def file_perms(path)
+      perms = sprintf("%o", File.stat(path).mode)
+      perms.reverse[0..2].reverse
+    end
+
+    # Returns the port which is either given in the options hash or taken from
+    # the config by finding it in the forwarded ports hash based on the
+    # `config.ssh.forwarded_port_key`
+    def port(opts={})
+      opts[:port] || env.config.vm.forwarded_ports[env.config.ssh.forwarded_port_key][:hostport]
     end
   end
 end

data/lib/vagrant/util.rb

@@ -10,12 +10,12 @@ module Vagrant
       puts "====================================================================="
     end
 
-    def error_and_exit(error)
+    def error_and_exit(key, data = {})
       abort <<-error
 =====================================================================
 Vagrant experienced an error!
 
-#{error.chomp}
+#{Errors.error_string(key, data).chomp}
 =====================================================================
 error
     end

data/lib/vagrant/util/errors.rb

@@ -0,0 +1,36 @@
+require 'yaml'
+
+module Vagrant
+  module Util
+    # This class is responsible for outputting errors. It retrieves the errors,
+    # based on their key, from the error file, and then outputs it.
+    class Errors
+      @@errors = nil
+
+      class <<self
+        # Resets the internal errors hash to nil, forcing a reload on the next
+        # access of {errors}.
+        def reset!
+          @@errors = nil
+        end
+
+        # Returns the hash of errors from the error YML files. This only loads once,
+        # then returns a cached value until {reset!} is called.
+        #
+        # @return [Hash]
+        def errors
+          @@errors ||= YAML.load_file(File.join(PROJECT_ROOT, "templates", "errors.yml"))
+        end
+
+        # Renders the error with the given key and data parameters and returns
+        # the rendered result.
+        #
+        # @return [String]
+        def error_string(key, data = {})
+          template = errors[key] || "Unknown error key: #{key}"
+          TemplateRenderer.render_string(template, data)
+        end
+      end
+    end
+  end
+end

data/lib/vagrant/util/platform.rb

@@ -0,0 +1,12 @@
+module Vagrant
+  module Util
+    # This class just contains some platform checking code.
+    class Platform
+      class <<self
+        def leopard?
+          RUBY_PLATFORM.downcase.include?("darwin9")
+        end
+      end
+    end
+  end
+end

data/lib/vagrant/util/progress_meter.rb

@@ -0,0 +1,33 @@
+module Vagrant
+  module Util
+    # A mixin which allows any class to be able to show a "progress meter"
+    # to standard out. The progress meter shows the progress of an operation
+    # with console-animated text in stdout.
+    module ProgressMeter
+      # Updates the progress meter with the given progress amount and total.
+      # This method will do the math to figure out a percentage and show it
+      # within stdout.
+      #
+      # @param [Float] progress Progress
+      # @param [Float] total Total
+      def update_progress(progress, total, show_parts=true)
+        percent = (progress.to_f / total.to_f) * 100
+        print "#{cl_reset}Progress: #{percent.to_i}%"
+        print " (#{progress} / #{total})" if show_parts
+        $stdout.flush
+      end
+
+      # Completes the progress meter by resetting it off of the screen.
+      def complete_progress
+        # Just clear the line back out
+        print "#{cl_reset}"
+      end
+
+      def cl_reset
+        reset = "\r"
+        reset += "\e[0K" unless Mario::Platform.windows?
+        reset
+      end
+    end
+  end
+end

data/lib/vagrant/util/stacked_proc_runner.rb

@@ -0,0 +1,35 @@
+module Vagrant
+  module Util
+    # Represents the "stacked proc runner" behavior which is used a
+    # couple places within Vagrant. This allows procs to "stack" on
+    # each other, then all execute in a single action. An example of
+    # its uses can be seen in the {Config} class.
+    module StackedProcRunner
+      # Returns the proc stack. This should always be called as the
+      # accessor of the stack. The instance variable itself should _never_
+      # be used.
+      #
+      # @return [Array<Proc>]
+      def proc_stack
+        @_proc_stack ||= []
+      end
+
+      # Adds (pushes) a proc to the stack. The actual proc added here is
+      # not executed, but merely stored.
+      #
+      # @param [Proc] block
+      def push_proc(&block)
+        proc_stack << block
+      end
+
+      # Executes all the procs on the stack, passing in the given arguments.
+      # The stack is not cleared afterwords. It is up to the user of this
+      # mixin to clear the stack by calling `proc_stack.clear`.
+      def run_procs!(*args)
+        proc_stack.each do |proc|
+          proc.call(*args)
+        end
+      end
+    end
+  end
+end

data/lib/vagrant/util/template_renderer.rb

@@ -0,0 +1,83 @@
+require 'ostruct'
+require 'erb'
+
+module Vagrant
+  module Util
+    # This class is used to render the ERB templates in the
+    # `GEM_ROOT/templates` directory.
+    class TemplateRenderer < OpenStruct
+      class <<self
+        # Render a given template and return the result. This method optionally
+        # takes a block which will be passed the renderer prior to rendering, which
+        # allows the caller to set any view variables within the renderer itself.
+        #
+        # @return [String] Rendered template
+        def render(*args)
+          render_with(:render, *args)
+        end
+
+        # Render a given string and return the result. This method optionally
+        # takes a block which will be passed the renderer prior to rendering, which
+        # allows the caller to set any view variables within the renderer itself.
+        #
+        # @param [String] template The template data string.
+        # @return [String] Rendered template
+        def render_string(*args)
+          render_with(:render_string, *args)
+        end
+
+        # Method used internally to DRY out the other renderers. This method
+        # creates and sets up the renderer before calling a specified method on it.
+        def render_with(method, template, data={})
+          renderer = new(template, data)
+          yield renderer if block_given?
+          renderer.send(method.to_sym)
+        end
+      end
+
+      def initialize(template, data = {})
+        super()
+
+        data[:template] = template
+        data.each do |key, value|
+          send("#{key}=", value)
+        end
+      end
+
+      # Renders the template using the class intance as the binding. Because the
+      # renderer inherits from `OpenStruct`, additional view variables can be
+      # added like normal accessors.
+      #
+      # @return [String]
+      def render
+        # TODO: Seems like a pretty dirty way to do this. Perhaps refactor this
+        old_template = template
+        result = nil
+        File.open(full_template_path, 'r') do |f|
+          self.template = f.read
+          result = render_string
+        end
+
+        result
+      ensure
+        self.template = old_template
+      end
+
+      # Renders a template, handling the template as a string, but otherwise
+      # acting the same way as {#render}.
+      #
+      # @return [String]
+      def render_string
+        ERB.new(template).result(binding)
+      end
+
+      # Returns the full path to the template, taking into accoun the gem directory
+      # and adding the `.erb` extension to the end.
+      #
+      # @return [String]
+      def full_template_path
+        File.join(PROJECT_ROOT, 'templates', "#{template}.erb")
+      end
+    end
+  end
+end