boxcar 0.10005.1

data/lib/vagrant/hosts/fedora.rb

@@ -0,0 +1,47 @@
+require 'pathname'
+
+module Vagrant
+  module Hosts
+    class Fedora < Linux
+      def self.match?
+        release_file = Pathname.new("/etc/redhat-release")
+
+        if release_file.exist?
+          release_file.open("r") do |f|
+            return true if f.gets =~ /^Fedora/
+          end
+        end
+
+        false
+      end
+
+      # Normal, mid-range precedence.
+      def self.precedence
+        5
+      end
+
+      def initialize(*args)
+        super
+
+        @nfs_server_binary = "/etc/init.d/nfs"
+
+        # On Fedora 16+, systemd replaced init.d, so we have to use the
+        # proper NFS binary. This checks to see if we need to do that.
+        release_file = Pathname.new("/etc/redhat-release")
+        begin
+          release_file.open("r") do |f|
+            version_number = /Fedora release ([0-9]+)/.match(f.gets)[1].to_i
+            if version_number >= 16
+              # "service nfs-server" will redirect properly to systemctl
+              # when "service nfs-server restart" is called.
+              @nfs_server_binary = "/usr/sbin/service nfs-server"
+            end
+          end
+        rescue Errno::ENOENT
+          # File doesn't exist, not a big deal, assume we're on a
+          # lower version.
+        end
+      end
+    end
+  end
+end

data/lib/vagrant/hosts/freebsd.rb

@@ -0,0 +1,41 @@
+require 'vagrant/util/platform'
+
+module Vagrant
+  module Hosts
+    # Represents a FreeBSD host
+    class FreeBSD < BSD
+      class FreeBSDHostError < Errors::VagrantError
+        error_namespace("vagrant.hosts.freebsd")
+      end
+
+      include Util
+      include Util::Retryable
+
+      def self.match?
+        Util::Platform.freebsd?
+      end
+
+      # Normal, mid-range precedence.
+      def self.precedence
+        5
+      end
+
+      def nfs_export(id, ip, folders)
+        folders.each do |folder_name, folder_values|
+          if folder_values[:hostpath] =~ /\s+/
+            raise FreeBSDHostError, :_key => :nfs_whitespace
+          end
+        end
+
+        super
+      end
+
+      def initialize(*args)
+        super
+
+        @nfs_restart_command = "sudo /etc/rc.d/mountd onereload"
+        @nfs_exports_template = "nfs/exports_freebsd"
+      end
+    end
+  end
+end

data/lib/vagrant/hosts/gentoo.rb

@@ -0,0 +1,20 @@
+module Vagrant
+  module Hosts
+    class Gentoo < Linux
+      def self.match?
+        return File.exists?("/etc/gentoo-release")
+      end
+
+      # Normal, mid-range precedence.
+      def self.precedence
+        5
+      end
+
+      def initialize(*args)
+        super
+
+        @nfs_server_binary = "/etc/init.d/nfs"
+      end
+    end
+  end
+end

data/lib/vagrant/hosts/linux.rb

@@ -0,0 +1,94 @@
+require 'log4r'
+
+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.match?
+        Util::Platform.linux?
+      end
+
+      def self.precedence
+        # Set a lower precedence because this is a generic OS. We
+        # want specific distros to match first.
+        2
+      end
+
+      def initialize(*args)
+        super
+
+        @logger = Log4r::Logger.new("vagrant::hosts::linux")
+        @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(id, ip, folders)
+        output = TemplateRenderer.render('nfs/exports_linux',
+                                         :uuid => id,
+                                         :ip => ip,
+                                         :folders => folders)
+
+        @ui.info I18n.t("vagrant.hosts.linux.nfs_export")
+        sleep 0.5
+
+        nfs_cleanup(id)
+
+        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_prune(valid_ids)
+        return if !File.exist?("/etc/exports")
+
+        @logger.info("Pruning invalid NFS entries...")
+
+        output = false
+
+        File.read("/etc/exports").lines.each do |line|
+          if line =~ /^# VAGRANT-BEGIN: (.+?)$/
+            if valid_ids.include?($1.to_s)
+              @logger.debug("Valid ID: #{$1.to_s}")
+            else
+              if !output
+                # We want to warn the user but we only want to output once
+                @ui.info I18n.t("vagrant.hosts.linux.nfs_prune")
+                output = true
+              end
+
+              @logger.info("Invalid ID, pruning: #{$1.to_s}")
+              nfs_cleanup($1.to_s)
+            end
+          end
+        end
+      end
+
+      protected
+
+      def nfs_cleanup(id)
+        return if !File.exist?("/etc/exports")
+
+        # Use sed to just strip out the block of code which was inserted
+        # by Vagrant
+        system("sudo sed -e '/^# VAGRANT-BEGIN: #{id}/,/^# VAGRANT-END: #{id}/ d' -ibak /etc/exports")
+      end
+    end
+  end
+end

data/lib/vagrant/hosts/opensuse.rb

@@ -0,0 +1,30 @@
+require 'pathname'
+
+module Vagrant
+  module Hosts
+    class OpenSUSE < Linux
+      def self.match?
+        release_file = Pathname.new("/etc/SuSE-release")
+
+        if release_file.exist?
+          release_file.open("r") do |f|
+            return true if f.gets =~ /^openSUSE/
+          end
+        end
+
+        false
+      end
+
+      # Normal, mid-range precedence.
+      def self.precedence
+        5
+      end
+
+      def initialize(*args)
+        super
+
+        @nfs_server_binary = "/etc/init.d/nfsserver"
+      end
+    end
+  end
+end

data/lib/vagrant/hosts/windows.rb

@@ -0,0 +1,16 @@
+require 'vagrant/util/platform'
+
+module Vagrant
+  module Hosts
+    class Windows < Base
+      def self.match?
+        Util::Platform.windows?
+      end
+
+      # Windows does not support NFS
+      def nfs?
+        false
+      end
+    end
+  end
+end

data/lib/vagrant/plugin.rb

@@ -0,0 +1,81 @@
+require "rubygems"
+
+require "log4r"
+
+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 gem specifications that were loaded as plugins.
+    @@plugins = []
+
+    # 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!
+      logger = Log4r::Logger.new("vagrant::plugin")
+      logger.info("Searching and loading any available plugins...")
+
+      # 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 @@plugins.include?(spec)
+            logger.debug("Plugin already loaded, not loading again: #{spec.name}")
+            next
+          end
+
+          # 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" }
+          if vagrant_dep && !vagrant_dep.requirement.satisfied_by?(our_version)
+            logger.debug("Plugin Vagrant dependency mismatch: #{spec.name} (#{spec.version})")
+            next
+          end
+
+          # 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
+
+          logger.info("Loading plugin: #{spec.name} (#{spec.version})")
+          @@plugins << spec
+          load file
+        end
+
+        logger.info("Loaded #{@@plugins.length} plugins.")
+      end
+    end
+
+    # Returns the array of plugins which are currently loaded by
+    # Vagrant.
+    #
+    # @return [Array]
+    def self.plugins; @@plugins; end
+  end
+end

data/lib/vagrant/provisioners.rb

@@ -0,0 +1,12 @@
+# These aren't autoloaded because they have to register things such
+# as configuration classes right away with Vagrant.
+module Vagrant
+  module Provisioners
+    autoload :Base,         'vagrant/provisioners/base'
+    autoload :ChefSolo,     'vagrant/provisioners/chef_solo'
+    autoload :ChefClient,   'vagrant/provisioners/chef_client'
+    autoload :Puppet,       'vagrant/provisioners/puppet'
+    autoload :PuppetServer, 'vagrant/provisioners/puppet_server'
+    autoload :Shell,        'vagrant/provisioners/shell'
+  end
+end

data/lib/vagrant/provisioners/base.rb

@@ -0,0 +1,44 @@
+module Vagrant
+  module Provisioners
+    # The base class for a "provisioner." A provisioner is responsible for
+    # provisioning a Vagrant system.
+    #
+    # This has been abstracted out so it is easy to provide support for
+    # multiple solutions.
+    class Base
+      include Vagrant::Util
+
+      # The environment which provisioner is running in. This is the
+      # action environment, not a Vagrant::Environment.
+      attr_reader :env
+
+      # The configuration for this provisioner. This will be an instance of
+      # the `Config` class which is part of the provisioner.
+      attr_reader :config
+
+      def initialize(env, config)
+        @env = env
+        @config = config
+      end
+
+      # This method is expected to return a class that is used for configuration
+      # for the provisioner.
+      def self.config_class; 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,168 @@
+require 'tempfile'
+
+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)
+        # Checks for the existence of chef binary and error if it
+        # doesn't exist.
+        env[:vm].channel.sudo("which #{binary}",
+                              :error_class => ChefError,
+                              :error_key => :chef_not_detected,
+                              :binary => binary)
+      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
+        env[:vm].channel.sudo("mkdir -p #{config.provisioning_path}")
+        env[:vm].channel.sudo("chown #{env[:vm].config.ssh.username} #{config.provisioning_path}")
+      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))
+
+        # Create a temporary file to store the data so we
+        # can upload it
+        temp = Tempfile.new("vagrant")
+        temp.write(config_file)
+        temp.close
+
+        remote_file = File.join(config.provisioning_path, filename)
+        env[:vm].channel.sudo("rm #{remote_file}", :error_check => false)
+        env[:vm].channel.upload(temp.path, remote_file)
+      end
+
+      def setup_json
+        env[:ui].info I18n.t("vagrant.provisioners.chef.json")
+
+        # Set up our configuration that is passed to the attributes by default
+        data = { :config => env[:global_config].to_hash }
+
+        # Add our default share directory if it exists
+        default_share = env[:vm].config.vm.shared_folders["v-root"]
+        data[:directory] = default_share[:guestpath] if default_share
+
+        # 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
+
+        # Create a temporary file to store the data so we
+        # can upload it
+        temp = Tempfile.new("vagrant")
+        temp.write(json)
+        temp.close
+
+        env[:vm].channel.upload(temp.path, 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_accessor :attempts
+        attr_writer :run_list
+
+        # Provide defaults in such a way that they won't override the instance
+        # variable. This is so merging continues to work properly.
+        def attempts; @attempts || 1; end
+        def json; @json ||= {}; end
+        def log_level; @log_level || :info; 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 validate(env, errors)
+          super
+
+          errors.add(I18n.t("vagrant.config.chef.vagrant_as_json_key")) if json.has_key?(:vagrant)
+        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