vagrant 0.7.0.beta → 0.7.0.beta2

data/lib/vagrant/hosts.rb

@@ -0,0 +1,7 @@
+module Vagrant
+  module Hosts
+    autoload :Base,  'vagrant/hosts/base'
+    autoload :BSD,   'vagrant/hosts/bsd'
+    autoload :Linux, 'vagrant/hosts/linux'
+  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/provisioners/base.rb

@@ -11,8 +11,26 @@ module Vagrant
       # {Vagrant::Action::Environment}
       attr_reader :action_env
 
-      def initialize(env)
+      # The configuration for this provisioner. This will be an instance of
+      # the `Config` class which is part of the provisioner.
+      attr_reader :config
+
+      # Registers a provisioner with a given shortcut. This allows that provisioner
+      # to be referenced with the shortcut.
+      #
+      # @param [Symbol] shortcut
+      def self.register(shortcut)
+        registered[shortcut] = self
+      end
+
+      # Returns the provisioner associated with the given shortcut.
+      def self.registered
+        @@registered ||= {}
+      end
+
+      def initialize(env, config)
         @action_env = env
+        @config = config
       end
 
       # Returns the actual {Vagrant::Environment} which this provisioner

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,95 @@
 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 :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"
+          @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
+        def validate(errors)
+          super
 
-    def check_manifest_dir
-      Dir.mkdir(env.config.puppet.manifests_path) unless File.directory?(env.config.puppet.manifests_path)
-    end
+          if !expanded_manifests_path.directory?
+            errors.add(I18n.t("vagrant.provisioners.puppet.manifests_path_missing", :path => expanded_manifests_path))
+            return
+          end
 
-    def share_manifests
-      env.config.vm.share_folder("manifests", env.config.puppet.pp_path, env.config.puppet.manifests_path)
-    end
+          errors.add(I18n.t("vagrant.provisioners.puppet.manifest_missing", :manifest => computed_manifest_file)) if !expanded_manifests_path.join(computed_manifest_file).file?
+        end
+      end
 
-    def verify_binary(binary)
-      vm.ssh.execute do |ssh|
-        ssh.exec!("which #{binary}", :error_class => PuppetError, :_key => :puppet_not_detected, :binary => binary)
+      def prepare
+        share_manifests
       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 provision!
+        verify_binary("puppet")
+        create_pp_path
+        run_puppet_client
       end
-    end
 
-    def set_manifest
-      @manifest = !env.config.puppet.manifest_file.empty? ? env.config.puppet.manifest_file : "#{env.config.vm.box}.pp"
+      def share_manifests
+        env.config.vm.share_folder("manifests", config.pp_path, config.manifests_path)
+      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 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
-    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 create_pp_path
+        vm.ssh.execute do |ssh|
+          ssh.exec!("sudo mkdir -p #{config.pp_path}")
+          ssh.exec!("sudo chown #{env.config.ssh.username} #{config.pp_path}")
+        end
+      end
+
+      def run_puppet_client
+        options = [config.options].flatten
+        options << config.computed_manifest_file
+        options = options.join(" ")
+
+        command = "sudo -i 'cd #{config.pp_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