fixed-vagrant 0.7.4.dev

data/lib/vagrant/hosts/linux.rb

@@ -0,0 +1,47 @@
+module Vagrant
+  module Hosts
+    # Represents a Linux based host, such as Ubuntu.
+    class Linux < Base
+      include Util
+      include Util::Retryable
+
+      def nfs?
+        retryable(:tries => 10, :on => TypeError) do
+          # Check procfs to see if NFSd is a supported filesystem
+          system("cat /proc/filesystems | grep nfsd > /dev/null 2>&1")
+        end
+      end
+
+      def nfs_export(ip, folders)
+        output = TemplateRenderer.render('nfs/exports_linux',
+                                         :uuid => env.vm.uuid,
+                                         :ip => ip,
+                                         :folders => folders)
+
+        env.ui.info I18n.t("vagrant.hosts.linux.nfs_export.prepare")
+        sleep 0.5
+
+        output.split("\n").each do |line|
+          # This should only ask for administrative permission once, even
+          # though its executed in multiple subshells.
+          system(%Q[sudo su root -c "echo '#{line}' >> /etc/exports"])
+        end
+
+        # We run restart here instead of "update" just in case nfsd
+        # is not starting
+        system("sudo /etc/init.d/nfs-kernel-server restart")
+      end
+
+      def nfs_cleanup
+        return if !File.exist?("/etc/exports")
+        system("cat /etc/exports | grep 'VAGRANT-BEGIN: #{env.vm.uuid}' > /dev/null 2>&1")
+
+        if $?.to_i == 0
+          # Use sed to just strip out the block of code which was inserted
+          # by Vagrant
+          system("sudo sed -e '/^# VAGRANT-BEGIN: #{env.vm.uuid}/,/^# VAGRANT-END: #{env.vm.uuid}/ d' -ibak /etc/exports")
+        end
+      end
+    end
+  end
+end

data/lib/vagrant/plugin.rb

@@ -0,0 +1,57 @@
+require "rubygems"
+
+module Vagrant
+  # Represents a single plugin and also manages loading plugins from
+  # RubyGems. If a plugin has a `vagrant_init.rb` file somewhere on its
+  # load path, then this class will find it and load it. For logging purposes
+  # (for debugging), the list of loaded plugins is stored in the {plugins}
+  # array.
+  class Plugin
+    # The array of loaded plugins.
+    @@plugins = []
+
+    # The gemspec of this plugin. This is an actual gemspec object.
+    attr_reader :gemspec
+
+    # The path to the `vagrant_init.rb` file which was loaded for this plugin.
+    attr_reader :file
+
+    # Loads all the plugins for Vagrant. Plugins are currently
+    # gems which have a "vagrant_init.rb" somewhere on their
+    # load path. This file is loaded to kick off the load sequence
+    # for that plugin.
+    def self.load!
+      # Stupid hack since Rails 2.3.x overrides Gem.source_index with their
+      # own incomplete replacement which causes issues.
+      index = Gem.source_index
+      index = [index.installed_source_index, index.vendor_source_index] if defined?(Rails::VendorGemSourceIndex) && index.is_a?(Rails::VendorGemSourceIndex)
+
+      # Look for a vagrant_init.rb in all the gems, but only the
+      # latest version of the gems.
+      [index].flatten.each do |source|
+        source.latest_specs.each do |spec|
+          file = Gem.searcher.matching_files(spec, "vagrant_init.rb").first
+          next if !file
+
+          @@plugins << new(spec, file)
+        end
+      end
+    end
+
+    # Returns the array of plugins which are currently loaded by
+    # Vagrant.
+    #
+    # @return [Array]
+    def self.plugins; @@plugins; end
+
+    # Initializes a new plugin, given a Gemspec and the path to the
+    # gem's `vagrant_init.rb` file. This should never be called manually.
+    # Instead {load!} creates all the instances.
+    def initialize(spec, file)
+      @gemspec = spec
+      @file = file
+
+      load file
+    end
+  end
+end

data/lib/vagrant/provisioners.rb

@@ -0,0 +1,9 @@
+# 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'
+require 'vagrant/provisioners/shell'

data/lib/vagrant/provisioners/base.rb

@@ -0,0 +1,63 @@
+module Vagrant
+  module Provisioners
+    # The base class for a "provisioner." A provisioner is responsible for
+    # provisioning a Vagrant system. This has been abstracted out to provide
+    # support for multiple solutions such as Chef Solo, Chef Client, and
+    # Puppet.
+    class Base
+      include Vagrant::Util
+
+      # The environment which provisioner is running in. This is a
+      # {Vagrant::Action::Environment}
+      attr_reader :action_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
+      # represents.
+      #
+      # @return [Vagrant::Environment]
+      def env
+        action_env.env
+      end
+
+      # Returns the VM which this provisioner is working on.
+      #
+      # @return [Vagrant::VM]
+      def vm
+        env.vm
+      end
+
+      # This is the method called to "prepare" the provisioner. This is called
+      # before any actions are run by the action runner (see {Vagrant::Actions::Runner}).
+      # This can be used to setup shared folders, forward ports, etc. Whatever is
+      # necessary on a "meta" level.
+      def prepare; end
+
+      # This is the method called to provision the system. This method
+      # is expected to do whatever necessary to provision the system (create files,
+      # SSH, etc.)
+      def provision!; end
+    end
+  end
+end

data/lib/vagrant/provisioners/chef.rb

@@ -0,0 +1,130 @@
+module Vagrant
+  module Provisioners
+    # This class is a base class where the common functionality shared between
+    # chef-solo and chef-client provisioning are stored. This is **not an actual
+    # provisioner**. Instead, {ChefSolo} or {ChefServer} should be used.
+    class Chef < Base
+      def prepare
+        raise ChefError, :invalid_provisioner
+      end
+
+      def verify_binary(binary)
+        vm.ssh.execute do |ssh|
+          # Checks for the existence of chef binary and error if it
+          # doesn't exist.
+          ssh.sudo!("which #{binary}", :error_class => ChefError, :_key => :chef_not_detected, :binary => binary)
+        end
+      end
+
+      def chown_provisioning_folder
+        vm.ssh.execute do |ssh|
+          ssh.sudo!("mkdir -p #{config.provisioning_path}")
+          ssh.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 => 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(config.provisioning_path, filename))
+      end
+
+      def setup_json
+        env.ui.info I18n.t("vagrant.provisioners.chef.json")
+
+        # Set up initial configuration
+        data = {
+          :config => env.config.to_hash,
+          :directory => env.config.vm.shared_folders["v-root"][:guestpath],
+        }
+
+        # And wrap it under the "vagrant" namespace
+        data = { :vagrant => data }
+
+        # Merge with the "extra data" which isn't put under the
+        # vagrant namespace by default
+        data.merge!(config.json)
+
+        json = data.to_json
+
+        vm.ssh.upload!(StringIO.new(json), File.join(config.provisioning_path, "dna.json"))
+      end
+    end
+
+    class Chef < Base
+      class ChefError < Errors::VagrantError
+        error_namespace("vagrant.provisioners.chef")
+      end
+    end
+
+    class Chef < Base
+      # This is the configuration which is available through `config.chef`
+      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
+          @provisioning_path = "/tmp/vagrant-chef"
+          @log_level = :info
+          @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
+        def run_list
+          json[:run_list] ||= []
+        end
+
+        # Sets the run list to the specified value
+        def run_list=(value)
+          json[:run_list] = value
+        end
+
+        # Adds a recipe to the run list
+        def add_recipe(name)
+          name = "recipe[#{name}]" unless name =~ /^recipe\[(.+?)\]$/
+          run_list << name
+        end
+
+        # Adds a role to the run list
+        def add_role(name)
+          name = "role[#{name}]" unless name =~ /^role\[(.+?)\]$/
+          run_list << name
+        end
+
+        def instance_variables_hash
+          # Overridden so that the 'json' key could be removed, since its just
+          # merged into the config anyways
+          result = super
+          result.delete("json")
+          result
+        end
+      end
+    end
+  end
+end

data/lib/vagrant/provisioners/chef_server.rb

@@ -0,0 +1,103 @@
+require 'pathname'
+
+module Vagrant
+  module Provisioners
+    # 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
+        attr_accessor :file_cache_path
+        attr_accessor :file_backup_path
+
+        def initialize
+          super
+
+          @validation_client_name = "chef-validator"
+          @client_key_path = "/etc/chef/client.pem"
+          @file_cache_path = "/srv/chef/file_store"
+          @file_backup_path = "/srv/chef/cache"
+        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 config.validation_key_path.nil?
+        raise ChefError, :server_validation_key_doesnt_exist if !File.file?(validation_key_path)
+        raise ChefError, :server_url_required if config.chef_server_url.nil?
+      end
+
+      def provision!
+        verify_binary("chef-client")
+        chown_provisioning_folder
+        create_client_key_folder
+        upload_validation_key
+        setup_json
+        setup_server_config
+        run_chef_client
+      end
+
+      def create_client_key_folder
+        env.ui.info I18n.t("vagrant.provisioners.chef.client_key_folder")
+        path = Pathname.new(config.client_key_path)
+
+        vm.ssh.execute do |ssh|
+          ssh.sudo!("mkdir -p #{path.dirname}")
+        end
+      end
+
+      def upload_validation_key
+        env.ui.info I18n.t("vagrant.provisioners.chef.upload_validation_key")
+        vm.ssh.upload!(validation_key_path, guest_validation_key_path)
+      end
+
+      def setup_server_config
+        setup_config("chef_server_client", "client.rb", {
+          :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 => config.client_key_path,
+          :file_cache_path => config.file_cache_path,
+          :file_backup_path => config.file_backup_path
+        })
+      end
+
+      def run_chef_client
+        commands = ["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|
+          ssh.sudo!(commands) do |channel, type, data|
+            if type == :exit_status
+              ssh.check_exit_status(data, commands)
+            else
+              env.ui.info("#{data}: #{type}")
+            end
+          end
+        end
+      end
+
+      def validation_key_path
+        File.expand_path(config.validation_key_path, env.root_path)
+      end
+
+      def guest_validation_key_path
+        File.join(config.provisioning_path, "validation.pem")
+      end
+    end
+  end
+end

data/lib/vagrant/provisioners/chef_solo.rb

@@ -0,0 +1,142 @@
+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
+      end
+
+      def provision!
+        verify_binary("chef-solo")
+        chown_provisioning_folder
+        setup_json
+        setup_solo_config
+        run_chef_solo
+      end
+
+      def share_cookbook_folders
+        host_cookbook_paths.each_with_index do |cookbook, i|
+          env.config.vm.share_folder("v-csc-#{i}", cookbook_path(i), cookbook)
+        end
+      end
+
+      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
+
+      def setup_solo_config
+        setup_config("chef_solo_solo", "solo.rb", {
+          :node_name => config.node_name,
+          :provisioning_path => config.provisioning_path,
+          :cookbooks_path => cookbooks_path,
+          :recipe_url => config.recipe_url,
+          :roles_path => roles_path,
+        })
+      end
+
+      def run_chef_solo
+        commands = ["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|
+          ssh.sudo!(commands) do |channel, type, data|
+            if type == :exit_status
+              ssh.check_exit_status(data, commands)
+            else
+              env.ui.info("#{data}: #{type}")
+            end
+          end
+        end
+      end
+
+      def host_folder_paths(paths)
+        # Convert single cookbook paths such as "cookbooks" or [:vm, "cookbooks"]
+        # into a proper array representation.
+        paths = [paths] if paths.is_a?(String) || paths.first.is_a?(Symbol)
+
+        paths.inject([]) do |acc, path|
+          path = [:host, path] if !path.is_a?(Array)
+          type, path = path
+
+          acc << File.expand_path(path, env.root_path) if type == :host
+          acc
+        end
+      end
+
+      def folder_path(*args)
+        File.join(config.provisioning_path, args.join("-"))
+      end
+
+      def folders_path(folders, folder)
+        # Convert single cookbook paths such as "cookbooks" or [:vm, "cookbooks"]
+        # into a proper array representation.
+        folders = [folders] if folders.is_a?(String) || folders.first.is_a?(Symbol)
+
+        # Convert each path to the proper absolute path depending on if the path
+        # is a host path or a VM path
+        result = []
+        folders.each_with_index do |path, i|
+          path = [:host, path] if !path.is_a?(Array)
+          type, path = path
+
+          result << folder_path(folder, i) if type == :host
+          result << folder_path(path) if type == :vm
+        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[0].to_s if result.length == 1
+        result
+      end
+
+      def host_cookbook_paths
+        host_folder_paths(config.cookbooks_path)
+      end
+
+      def host_role_paths
+        host_folder_paths(config.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(config.cookbooks_path, "cookbooks").to_json
+      end
+
+      def roles_path
+        folders_path(config.roles_path, "roles").to_json
+      end
+    end
+  end
+end