vagrantup 0.6.9 → 0.7.0

data/lib/vagrant/provisioners/chef.rb

@@ -12,23 +12,30 @@ module Vagrant
         vm.ssh.execute do |ssh|
           # Checks for the existence of chef binary and error if it
           # doesn't exist.
-          ssh.exec!("which #{binary}", :error_class => ChefError, :_key => :chef_not_detected, :binary => binary)
+          ssh.exec!("sudo -i which #{binary}", :error_class => ChefError, :_key => :chef_not_detected, :binary => binary)
         end
       end
 
       def chown_provisioning_folder
         vm.ssh.execute do |ssh|
-          ssh.exec!("sudo mkdir -p #{env.config.chef.provisioning_path}")
-          ssh.exec!("sudo chown #{env.config.ssh.username} #{env.config.chef.provisioning_path}")
+          ssh.exec!("sudo mkdir -p #{config.provisioning_path}")
+          ssh.exec!("sudo chown #{env.config.ssh.username} #{config.provisioning_path}")
         end
       end
 
       def setup_config(template, filename, template_vars)
         config_file = TemplateRenderer.render(template, {
-          :log_level => env.config.chef.log_level.to_sym
+          :log_level => config.log_level.to_sym,
+          :http_proxy => config.http_proxy,
+          :http_proxy_user => config.http_proxy_user,
+          :http_proxy_pass => config.http_proxy_pass,
+          :https_proxy => config.https_proxy,
+          :https_proxy_user => config.https_proxy_user,
+          :https_proxy_pass => config.https_proxy_pass,
+          :no_proxy => config.no_proxy
         }.merge(template_vars))
 
-        vm.ssh.upload!(StringIO.new(config_file), File.join(env.config.chef.provisioning_path, filename))
+        vm.ssh.upload!(StringIO.new(config_file), File.join(config.provisioning_path, filename))
       end
 
       def setup_json
@@ -45,11 +52,11 @@ module Vagrant
 
         # Merge with the "extra data" which isn't put under the
         # vagrant namespace by default
-        data.merge!(env.config.chef.json)
+        data.merge!(config.json)
 
         json = data.to_json
 
-        vm.ssh.upload!(StringIO.new(json), File.join(env.config.chef.provisioning_path, "dna.json"))
+        vm.ssh.upload!(StringIO.new(json), File.join(config.provisioning_path, "dna.json"))
       end
     end
 
@@ -61,37 +68,31 @@ module Vagrant
 
     class Chef < Base
       # This is the configuration which is available through `config.chef`
-      class ChefConfig < Vagrant::Config::Base
-        configures :chef
-
-        # Chef server specific config
-        attr_accessor :chef_server_url
-        attr_accessor :validation_key_path
-        attr_accessor :validation_client_name
-        attr_accessor :client_key_path
-        attr_accessor :node_name
-
-        # Chef solo specific config
-        attr_accessor :cookbooks_path
-        attr_accessor :roles_path
-        attr_accessor :recipe_url
-
+      class Config < Vagrant::Config::Base
         # Shared config
+        attr_accessor :node_name
         attr_accessor :provisioning_path
         attr_accessor :log_level
         attr_accessor :json
+        attr_accessor :http_proxy
+        attr_accessor :http_proxy_user
+        attr_accessor :http_proxy_pass
+        attr_accessor :https_proxy
+        attr_accessor :https_proxy_user
+        attr_accessor :https_proxy_pass
+        attr_accessor :no_proxy
 
         def initialize
-          @validation_client_name = "chef-validator"
-          @client_key_path = "/etc/chef/client.pem"
-
-          @cookbooks_path = ["cookbooks", [:vm, "cookbooks"]]
-          @roles_path = []
           @provisioning_path = "/tmp/vagrant-chef"
           @log_level = :info
-          @json = {
-            :instance_role => "vagrant",
-          }
+          @json = { :instance_role => "vagrant" }
+          @http_proxy = nil
+          @http_proxy_user = nil
+          @http_proxy_pass = nil
+          @https_proxy = nil
+          @https_proxy_user = nil
+          @https_proxy_pass = nil
+          @no_proxy = nil
         end
 
         # Returns the run list for the provisioning
@@ -123,28 +124,6 @@ module Vagrant
           result.delete("json")
           result
         end
-
-        def validate(errors)
-          if top.vm.provisioner == :chef_solo
-            # Validate chef solo settings
-            errors.add(I18n.t("vagrant.config.chef.cookbooks_path_empty")) if !cookbooks_path || [cookbooks_path].flatten.empty?
-          end
-
-          if top.vm.provisioner == :chef_server
-            # Validate chef server settings
-            errors.add(I18n.t("vagrant.config.chef.server_url_empty")) if !chef_server_url || chef_server_url.strip == ""
-            errors.add(I18n.t("vagrant.config.chef.validation_key_path")) if !validation_key_path
-          end
-
-          if top.vm.provisioner == :chef_solo
-            # On chef solo, a run list MUST be specified
-            errors.add(I18n.t("vagrant.config.chef.run_list_empty")) if !json[:run_list] || run_list.empty?
-          elsif top.vm.provisioner == :chef_server
-            # On chef server, the run list is allowed to be nil, which causes it
-            # to sync with the chef server.
-            errors.add(I18n.t("vagrant.config.chef.run_list_empty")) if json[:run_list] && run_list.empty?
-          end
-        end
       end
     end
   end

data/lib/vagrant/provisioners/chef_server.rb

@@ -5,10 +5,34 @@ module Vagrant
     # This class implements provisioning via chef-client, allowing provisioning
     # with a chef server.
     class ChefServer < Chef
+      register :chef_server
+
+      class Config < Chef::Config
+        attr_accessor :chef_server_url
+        attr_accessor :validation_key_path
+        attr_accessor :validation_client_name
+        attr_accessor :client_key_path
+
+        def initialize
+          super
+
+          @validation_client_name = "chef-validator"
+          @client_key_path = "/etc/chef/client.pem"
+        end
+
+        def validate(errors)
+          super
+
+          errors.add(I18n.t("vagrant.config.chef.server_url_empty")) if !chef_server_url || chef_server_url.strip == ""
+          errors.add(I18n.t("vagrant.config.chef.validation_key_path")) if !validation_key_path
+          errors.add(I18n.t("vagrant.config.chef.run_list_empty")) if json[:run_list] && run_list.empty?
+        end
+      end
+
       def prepare
-        raise ChefError, :server_validation_key_required if env.config.chef.validation_key_path.nil?
+        raise ChefError, :server_validation_key_required if config.validation_key_path.nil?
         raise ChefError, :server_validation_key_doesnt_exist if !File.file?(validation_key_path)
-        raise ChefError, :server_url_required if env.config.chef.chef_server_url.nil?
+        raise ChefError, :server_url_required if config.chef_server_url.nil?
       end
 
       def provision!
@@ -23,7 +47,7 @@ module Vagrant
 
       def create_client_key_folder
         env.ui.info I18n.t("vagrant.provisioners.chef.client_key_folder")
-        path = Pathname.new(env.config.chef.client_key_path)
+        path = Pathname.new(config.client_key_path)
 
         vm.ssh.execute do |ssh|
           ssh.exec!("sudo mkdir -p #{path.dirname}")
@@ -37,16 +61,16 @@ module Vagrant
 
       def setup_server_config
         setup_config("chef_server_client", "client.rb", {
-          :node_name => env.config.chef.node_name,
-          :chef_server_url => env.config.chef.chef_server_url,
-          :validation_client_name => env.config.chef.validation_client_name,
+          :node_name => config.node_name,
+          :chef_server_url => config.chef_server_url,
+          :validation_client_name => config.validation_client_name,
           :validation_key => guest_validation_key_path,
-          :client_key => env.config.chef.client_key_path
+          :client_key => config.client_key_path
         })
       end
 
       def run_chef_client
-        command = "cd #{env.config.chef.provisioning_path} && sudo -E chef-client -c client.rb -j dna.json"
+        command = "sudo -i 'cd #{config.provisioning_path} && chef-client -c client.rb -j dna.json'"
 
         env.ui.info I18n.t("vagrant.provisioners.chef.running_client")
         vm.ssh.execute do |ssh|
@@ -61,11 +85,11 @@ module Vagrant
       end
 
       def validation_key_path
-        File.expand_path(env.config.chef.validation_key_path, env.root_path)
+        File.expand_path(config.validation_key_path, env.root_path)
       end
 
       def guest_validation_key_path
-        File.join(env.config.chef.provisioning_path, "validation.pem")
+        File.join(config.provisioning_path, "validation.pem")
       end
     end
   end

data/lib/vagrant/provisioners/chef_solo.rb

@@ -2,6 +2,28 @@ module Vagrant
   module Provisioners
     # This class implements provisioning via chef-solo.
     class ChefSolo < Chef
+      register :chef_solo
+
+      class Config < Chef::Config
+        attr_accessor :cookbooks_path
+        attr_accessor :roles_path
+        attr_accessor :recipe_url
+
+        def initialize
+          super
+
+          @cookbooks_path = ["cookbooks", [:vm, "cookbooks"]]
+          @roles_path = []
+        end
+
+        def validate(errors)
+          super
+
+          errors.add(I18n.t("vagrant.config.chef.cookbooks_path_empty")) if !cookbooks_path || [cookbooks_path].flatten.empty?
+          errors.add(I18n.t("vagrant.config.chef.run_list_empty")) if !json[:run_list] || run_list.empty?
+        end
+      end
+
       def prepare
         share_cookbook_folders
         share_role_folders
@@ -29,16 +51,16 @@ module Vagrant
 
       def setup_solo_config
         setup_config("chef_solo_solo", "solo.rb", {
-          :node_name => env.config.chef.node_name,
-          :provisioning_path => env.config.chef.provisioning_path,
+          :node_name => config.node_name,
+          :provisioning_path => config.provisioning_path,
           :cookbooks_path => cookbooks_path,
-          :recipe_url => env.config.chef.recipe_url,
+          :recipe_url => config.recipe_url,
           :roles_path => roles_path,
         })
       end
 
       def run_chef_solo
-        command = "cd #{env.config.chef.provisioning_path} && sudo -E chef-solo -c solo.rb -j dna.json"
+        command = "sudo -i 'cd #{config.provisioning_path} && chef-solo -c solo.rb -j dna.json'"
 
         env.ui.info I18n.t("vagrant.provisioners.chef.running_solo")
         vm.ssh.execute do |ssh|
@@ -64,7 +86,7 @@ module Vagrant
       end
 
       def folder_path(*args)
-        File.join(env.config.chef.provisioning_path, args.join("-"))
+        File.join(config.provisioning_path, args.join("-"))
       end
 
       def folders_path(folders, folder)
@@ -90,11 +112,11 @@ module Vagrant
       end
 
       def host_cookbook_paths
-        host_folder_paths(env.config.chef.cookbooks_path)
+        host_folder_paths(config.cookbooks_path)
       end
 
       def host_role_paths
-        host_folder_paths(env.config.chef.roles_path)
+        host_folder_paths(config.roles_path)
       end
 
       def cookbook_path(i)
@@ -106,11 +128,11 @@ module Vagrant
       end
 
       def cookbooks_path
-        folders_path(env.config.chef.cookbooks_path, "cookbooks").to_json
+        folders_path(config.cookbooks_path, "cookbooks").to_json
       end
 
       def roles_path
-        folders_path(env.config.chef.roles_path, "roles").to_json
+        folders_path(config.roles_path, "roles").to_json
       end
     end
   end

data/lib/vagrant/provisioners/puppet.rb

@@ -1,85 +1,136 @@
 module Vagrant
   module Provisioners
+    class PuppetError < Vagrant::Errors::VagrantError
+      error_namespace("vagrant.provisioners.puppet")
+    end
 
-  class PuppetError < Vagrant::Errors::VagrantError
-    error_namespace("vagrant.provisioners.puppet")
-  end
+    class Puppet < Base
+      register :puppet
 
-  class PuppetConfig < Vagrant::Config::Base
-    configures :puppet
+      class Config < Vagrant::Config::Base
+        attr_accessor :manifest_file
+        attr_accessor :manifests_path
+        attr_accessor :module_path
+        attr_accessor :pp_path
+        attr_accessor :options
 
-    attr_accessor :manifest_file
-    attr_accessor :manifests_path
-    attr_accessor :pp_path
-    attr_accessor :options
+        def initialize
+          @manifest_file = nil
+          @manifests_path = "manifests"
+          @module_path = nil
+          @pp_path = "/tmp/vagrant-puppet"
+          @options = []
+        end
 
-    def initialize
-      @manifest_file = ""
-      @manifests_path = "manifests"
-      @pp_path = "/tmp/vagrant-puppet"
-      @options = []
-    end
-  end
+        # Returns the manifests path expanded relative to the root path of the
+        # environment.
+        def expanded_manifests_path
+          Pathname.new(manifests_path).expand_path(env.root_path)
+        end
 
-  class Puppet < Base
-    def prepare
-      check_manifest_dir
-      share_manifests
-    end
+        # Returns the manifest file if set otherwise returns the box name pp file
+        # which may or may not exist.
+        def computed_manifest_file
+          manifest_file || "#{top.vm.box}.pp"
+        end
 
-    def provision!
-      verify_binary("puppet")
-      create_pp_path
-      set_manifest
-      run_puppet_client
-    end
+        # Returns the module paths as an array of paths expanded relative to the
+        # root path.
+        def expanded_module_paths
+          return [] if !module_path
 
-    def check_manifest_dir
-      Dir.mkdir(env.config.puppet.manifests_path) unless File.directory?(env.config.puppet.manifests_path)
-    end
+          # Get all the paths and expand them relative to the root path, returning
+          # the array of expanded paths
+          paths = module_path
+          paths = [paths] if !paths.is_a?(Array)
+          paths.map do |path|
+            Pathname.new(path).expand_path(env.root_path)
+          end
+        end
 
-    def share_manifests
-      env.config.vm.share_folder("manifests", env.config.puppet.pp_path, env.config.puppet.manifests_path)
-    end
+        def validate(errors)
+          super
 
-    def verify_binary(binary)
-      vm.ssh.execute do |ssh|
-        ssh.exec!("which #{binary}", :error_class => PuppetError, :_key => :puppet_not_detected, :binary => binary)
+          # Manifests path/file validation
+          if !expanded_manifests_path.directory?
+            errors.add(I18n.t("vagrant.provisioners.puppet.manifests_path_missing", :path => expanded_manifests_path))
+          else
+            if !expanded_manifests_path.join(computed_manifest_file).file?
+              errors.add(I18n.t("vagrant.provisioners.puppet.manifest_missing", :manifest => computed_manifest_file))
+            end
+          end
+
+          # Module paths validation
+          expanded_module_paths.each do |path|
+            if !path.directory?
+              errors.add(I18n.t("vagrant.provisioners.puppet.module_path_missing", :path => path))
+            end
+          end
+        end
       end
-    end
 
-    def create_pp_path
-      vm.ssh.execute do |ssh|
-        ssh.exec!("sudo mkdir -p #{env.config.puppet.pp_path}")
-        ssh.exec!("sudo chown #{env.config.ssh.username} #{env.config.puppet.pp_path}")
+      def prepare
+        set_module_paths
+        share_manifests
+        share_module_paths
       end
-    end
 
-    def set_manifest
-      @manifest = !env.config.puppet.manifest_file.empty? ? env.config.puppet.manifest_file : "#{env.config.vm.box}.pp"
+      def provision!
+        verify_binary("puppet")
+        run_puppet_client
+      end
 
-      if File.exists?("#{env.config.puppet.manifests_path}/#{@manifest}")
-         env.ui.info I18n.t("vagrant.provisioners.puppet.manifest_to_run", :manifest => @manifest)
-         return @manifest
-       else
-         raise PuppetError, :_key => :manifest_missing, :manifest => @manifest
+      def share_manifests
+        env.config.vm.share_folder("manifests", manifests_guest_path, config.expanded_manifests_path)
       end
-    end
 
-    def run_puppet_client
-      options = env.config.puppet.options
-      options = options.join(" ") if options.is_a?(Array)
-      command = "cd #{env.config.puppet.pp_path} && sudo -E puppet #{options} #{@manifest}"
+      def share_module_paths
+        count = 0
+        @module_paths.each do |from, to|
+          # Sorry for the cryptic key here, but VirtualBox has a strange limit on
+          # maximum size for it and its something small (around 10)
+          env.config.vm.share_folder("v-pp-m#{count}", to, from)
+          count += 1
+        end
+      end
+
+      def set_module_paths
+        @module_paths = {}
+        config.expanded_module_paths.each_with_index do |path, i|
+          @module_paths[path] = File.join(config.pp_path, "modules-#{i}")
+        end
+      end
+
+      def manifests_guest_path
+        File.join(config.pp_path, "manifests")
+      end
+
+      def verify_binary(binary)
+        vm.ssh.execute do |ssh|
+          ssh.exec!("sudo -i which #{binary}", :error_class => PuppetError, :_key => :puppet_not_detected, :binary => binary)
+        end
+      end
+
+      def run_puppet_client
+        options = [config.options].flatten
+        options << "--modulepath '#{@module_paths.values.join(':')}'" if !@module_paths.empty?
+        options << config.computed_manifest_file
+        options = options.join(" ")
+
+        command = "sudo -i 'cd #{manifests_guest_path}; puppet #{options}'"
 
-      env.ui.info I18n.t("vagrant.provisioners.puppet.running_puppet")
+        env.ui.info I18n.t("vagrant.provisioners.puppet.running_puppet", :manifest => config.computed_manifest_file)
 
-      vm.ssh.execute do |ssh|
-        ssh.exec!(command) do |channel, type, data|
-          ssh.check_exit_status(data, command) if type == :exit_status
-          env.ui.info("#{data}: #{type}") if type != :exit_status
+        vm.ssh.execute do |ssh|
+          ssh.exec! command do |ch, type, data|
+            if type == :exit_status
+              ssh.check_exit_status(data, command)
+            else
+              env.ui.info(data)
+            end
+          end
         end
       end
     end
   end
- end
 end

data/lib/vagrant/provisioners/puppet_server.rb

@@ -0,0 +1,57 @@
+module Vagrant
+  module Provisioners
+    class PuppetServerError < Vagrant::Errors::VagrantError
+      error_namespace("vagrant.provisioners.puppet_server")
+    end
+
+    class PuppetServer < Base
+      register :puppet_server
+
+      class Config < Vagrant::Config::Base
+        attr_accessor :puppet_server
+        attr_accessor :puppet_node
+        attr_accessor :options
+
+        def initialize
+          @puppet_server = "puppet"
+          @puppet_node = "puppet_node"
+          @options = []
+        end
+      end
+
+      def provision!
+        verify_binary("puppetd")
+        run_puppetd_client
+      end
+
+      def verify_binary(binary)
+        vm.ssh.execute do |ssh|
+          ssh.shell do |sh|
+            sh.execute("sudo -i which #{binary}", :error_class => PuppetServerError, :_key => :puppetd_not_detected, :binary => binary)
+          end
+        end
+      end
+
+      def run_puppetd_client
+        options = config.options
+        options = options.join(" ") if options.is_a?(Array)
+        if config.puppet_node
+          cn = config.puppet_node
+        else
+          cn = env.config.vm.box
+        end
+
+        command = "sudo -i puppetd #{options} --server #{config.puppet_server} --certname #{cn}"
+
+        env.ui.info I18n.t("vagrant.provisioners.puppet_server.running_puppetd")
+
+        vm.ssh.execute do |ssh|
+          ssh.exec!(command) do |channel, type, data|
+            ssh.check_exit_status(data, command) if type == :exit_status
+            env.ui.info(data) if type != :exit_status
+          end
+        end
+      end
+    end
+  end
+end

data/lib/vagrant/provisioners.rb

@@ -0,0 +1,8 @@
+# These aren't autoloaded because they have to register things such
+# as configuration classes right away with Vagrant.
+require 'vagrant/provisioners/base'
+require 'vagrant/provisioners/chef'
+require 'vagrant/provisioners/chef_server'
+require 'vagrant/provisioners/chef_solo'
+require 'vagrant/provisioners/puppet'
+require 'vagrant/provisioners/puppet_server'

data/lib/vagrant/ssh/session.rb

@@ -0,0 +1,81 @@
+module Vagrant
+  class SSH
+    # A helper class which wraps around `Net::SSH::Connection::Session`
+    # in order to provide basic command error checking while still
+    # providing access to the actual session object.
+    class Session
+      include Util::Retryable
+
+      attr_reader :session
+
+      def initialize(session)
+        @session = session
+      end
+
+      # Executes a given command and simply returns true/false if the
+      # command succeeded or not.
+      def test?(command)
+        exec!(command) do |ch, type, data|
+          return true if type == :exit_status && data == 0
+        end
+
+        false
+      end
+
+      # Executes a given command on the SSH session and blocks until
+      # the command completes. This is an almost line for line copy of
+      # the actual `exec!` implementation, except that this
+      # implementation also reports `:exit_status` to the block if given.
+      def exec!(command, options=nil, &block)
+        options = { :error_check => true }.merge(options || {})
+
+        block ||= Proc.new do |ch, type, data|
+          check_exit_status(data, command, options) if type == :exit_status && options[:error_check]
+
+          ch[:result] ||= ""
+          ch[:result] << data if [:stdout, :stderr].include?(type)
+        end
+
+        retryable(:tries => 5, :on => IOError, :sleep => 0.5) do
+          metach = session.open_channel do |channel|
+            channel.exec(command) do |ch, success|
+              raise "could not execute command: #{command.inspect}" unless success
+
+              # Output stdout data to the block
+              channel.on_data do |ch2, data|
+                block.call(ch2, :stdout, data)
+              end
+
+              # Output stderr data to the block
+              channel.on_extended_data do |ch2, type, data|
+                block.call(ch2, :stderr, data)
+              end
+
+              # Output exit status information to the block
+              channel.on_request("exit-status") do |ch2, data|
+                block.call(ch2, :exit_status, data.read_long)
+              end
+            end
+          end
+
+          metach.wait
+          metach[:result]
+        end
+      end
+
+      # Checks for an erroroneous exit status and raises an exception
+      # if so.
+      def check_exit_status(exit_status, command, options=nil)
+        if exit_status != 0
+          options = {
+            :_error_class => Errors::VagrantError,
+            :_key => :ssh_bad_exit_status,
+            :command => command
+          }.merge(options || {})
+
+          raise options[:_error_class], options
+        end
+      end
+    end
+  end
+end