rvagrant 0.8.7.dev

data/lib/vagrant/hosts/bsd.rb

@@ -0,0 +1,58 @@
+require 'vagrant/util/platform'
+
+module Vagrant
+  module Hosts
+    # Represents a BSD host, such as FreeBSD and Darwin (Mac OS X).
+    class BSD < Base
+      include Util
+      include Util::Retryable
+
+      def self.distro_dispatch
+        return self if Util::Platform.darwin? || Util::Platform.bsd?
+      end
+
+      def nfs?
+        retryable(:tries => 10, :on => TypeError) do
+          system("which nfsd > /dev/null 2>&1")
+        end
+      end
+
+      def nfs_export(ip, folders)
+        output = TemplateRenderer.render('nfs/exports',
+                                         :uuid => env.vm.uuid,
+                                         :ip => ip,
+                                         :folders => folders)
+
+        # The sleep ensures that the output is truly flushed before any `sudo`
+        # commands are issued.
+        env.ui.info I18n.t("vagrant.hosts.bsd.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.
+          line = line.gsub('"', '\"')
+          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 nfsd restart")
+      end
+
+      def nfs_cleanup
+        return if !File.exist?("/etc/exports")
+
+        retryable(:tries => 10, :on => TypeError) do
+          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
+end

data/lib/vagrant/hosts/fedora.rb

@@ -0,0 +1,11 @@
+module Vagrant
+  module Hosts
+    class Fedora < Linux
+      def initialize(*args)
+        super
+
+        @nfs_server_binary = "/etc/init.d/nfs"
+      end
+    end
+  end
+end

data/lib/vagrant/hosts/linux.rb

@@ -0,0 +1,69 @@
+require 'vagrant/util/platform'
+
+module Vagrant
+  module Hosts
+    # Represents a Linux based host, such as Ubuntu.
+    class Linux < Base
+      include Util
+      include Util::Retryable
+
+      def self.distro_dispatch
+        return nil if !Util::Platform.linux?
+        return Arch if File.exist?("/etc/rc.conf") && File.exist?("/etc/pacman.conf")
+
+        if File.exist?("/etc/redhat-release")
+          # Check if we have a known redhat release
+          File.open("/etc/redhat-release") do |f|
+            return Fedora if f.gets =~ /^Fedora/
+          end
+        end
+
+        return self
+      end
+
+      def initialize(*args)
+        super
+
+        @nfs_server_binary = "/etc/init.d/nfs-kernel-server"
+      end
+
+      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 #{@nfs_server_binary} 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,79 @@
+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!
+      # Our version is used for checking dependencies
+      our_version = Gem::Version.create(Vagrant::VERSION)
+
+      # RubyGems 1.8.0 deprecated `source_index`. Gem::Specification is the
+      # new replacement. For now, we support both, but special-case 1.8.x
+      # so that we avoid deprecation messages.
+      index = Gem::VERSION >= "1.8.0" ? Gem::Specification : Gem.source_index
+
+      # Stupid hack since Rails 2.3.x overrides Gem.source_index with their
+      # own incomplete replacement which causes issues.
+      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|
+        # In 1.6.0, added the option of including prerelease gems, which is
+        # useful for developers.
+        specs = Gem::VERSION >= "1.6.0" ? source.latest_specs(true) : source.latest_specs
+
+        specs.each do |spec|
+          # If this gem depends on Vagrant, verify this is a valid release of
+          # Vagrant for this gem to load into.
+          vagrant_dep = spec.dependencies.find { |d| d.name == "vagrant" }
+          next if vagrant_dep && !vagrant_dep.requirement.satisfied_by?(our_version)
+
+          # Find a vagrant_init.rb to verify if this is a plugin
+          file = nil
+          if Gem::VERSION >= "1.8.0"
+            file = spec.matches_for_glob("**/vagrant_init.rb").first
+          else
+            file = Gem.searcher.matching_files(spec, "vagrant_init.rb").first
+          end
+
+          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_client'
+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,67 @@
+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
+
+      # This is the method called to when the system is being destroyed
+      # and allows the provisioners to engage in any cleanup tasks necessary.
+      def cleanup; end
+    end
+  end
+end

data/lib/vagrant/provisioners/chef.rb

@@ -0,0 +1,155 @@
+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
+      include Util::Counter
+
+      def initialize(env, config)
+        super
+
+        config.provisioning_path ||= "/tmp/vagrant-chef-#{get_and_update_counter(:provisioning_path)}"
+      end
+
+      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
+
+      # Returns the path to the Chef binary, taking into account the
+      # `binary_path` configuration option.
+      def chef_binary_path(binary)
+        return binary if !config.binary_path
+        return File.join(config.binary_path, binary)
+      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.merged_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
+        attr_accessor :binary_path
+        attr_accessor :binary_env
+        attr_writer :run_list
+
+        def initialize
+          @provisioning_path = nil
+          @log_level = :info
+          @json = {}
+          @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
+          @binary_path = nil
+          @binary_env = nil
+          @run_list = nil
+        end
+
+        # This returns the json that is merged with the defaults and the
+        # user set data.
+        def merged_json
+          original = { :instance_role => "vagrant" }
+          original[:run_list] = @run_list if @run_list
+          original.merge(json || {})
+        end
+
+        # Returns the run list, but also sets it up to be empty if it
+        # hasn't been defined already.
+        def run_list
+          @run_list ||= []
+        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