vagrant 1.0.7 → 2.4.4

data/lib/vagrant/provisioners/shell.rb

@@ -1,103 +0,0 @@
-require 'tempfile'
-
-module Vagrant
-  module Provisioners
-    class Shell < Base
-      class Config < Vagrant::Config::Base
-        attr_accessor :inline
-        attr_accessor :path
-        attr_accessor :upload_path
-        attr_accessor :args
-
-        def initialize
-          @upload_path = "/tmp/vagrant-shell"
-        end
-
-        def validate(env, errors)
-          # Validate that the parameters are properly set
-          if path && inline
-            errors.add(I18n.t("vagrant.provisioners.shell.path_and_inline_set"))
-          elsif !path && !inline
-            errors.add(I18n.t("vagrant.provisioners.shell.no_path_or_inline"))
-          end
-
-          # Validate the existence of a script to upload
-          if path
-            expanded_path = Pathname.new(path).expand_path(env.root_path)
-            if !expanded_path.file?
-              errors.add(I18n.t("vagrant.provisioners.shell.path_invalid",
-                                :path => expanded_path))
-            end
-          end
-
-          # There needs to be a path to upload the script to
-          if !upload_path
-            errors.add(I18n.t("vagrant.provisioners.shell.upload_path_not_set"))
-          end
-
-          # If there are args and its not a string, that is a problem
-          if args && !args.is_a?(String)
-            errors.add(I18n.t("vagrant.provisioners.shell.args_not_string"))
-          end
-        end
-      end
-
-      def self.config_class
-        Config
-      end
-
-      # This method yields the path to a script to upload and execute
-      # on the remote server. This method will properly clean up the
-      # script file if needed.
-      def with_script_file
-        if config.path
-          # Just yield the path to that file...
-          yield Pathname.new(config.path).expand_path(env[:root_path])
-          return
-        end
-
-        # Otherwise we have an inline script, we need to Tempfile it,
-        # and handle it specially...
-        file = Tempfile.new('vagrant-shell')
-
-        # Unless you set binmode, on a Windows host the shell script will
-        # have CRLF line endings instead of LF line endings, causing havoc
-        # when the guest executes it
-        file.binmode
-
-        begin
-          file.write(config.inline)
-          file.fsync
-          file.close
-          yield file.path
-        ensure
-          file.close
-          file.unlink
-        end
-      end
-
-      def provision!
-        args = ""
-        args = " #{config.args}" if config.args
-        command = "chmod +x #{config.upload_path} && #{config.upload_path}#{args}"
-
-        with_script_file do |path|
-          # Upload the script to the VM
-          env[:vm].channel.upload(path.to_s, config.upload_path)
-
-          # Execute it with sudo
-          env[:vm].channel.sudo(command) do |type, data|
-            if [:stderr, :stdout].include?(type)
-              # Output the data with the proper color based on the stream.
-              color = type == :stdout ? :green : :red
-
-              # Note: Be sure to chomp the data to avoid the newlines that the
-              # Chef outputs.
-              env[:ui].info(data.chomp, :color => color, :prefix => false)
-            end
-          end
-        end
-      end
-    end
-  end
-end

data/lib/vagrant/provisioners.rb

@@ -1,12 +0,0 @@
-# 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/ssh.rb

@@ -1,126 +0,0 @@
-require 'log4r'
-
-require 'vagrant/util/file_mode'
-require 'vagrant/util/platform'
-require 'vagrant/util/safe_exec'
-
-module Vagrant
-  # Manages SSH connection information as well as allows opening an
-  # SSH connection.
-  class SSH
-    include Util::SafeExec
-
-    def initialize(vm)
-      @vm     = vm
-      @logger = Log4r::Logger.new("vagrant::ssh")
-    end
-
-    # Returns a hash of information necessary for accessing this
-    # virtual machine via SSH.
-    #
-    # @return [Hash]
-    def info
-      results = {
-        :host          => @vm.config.ssh.host,
-        :port          => @vm.config.ssh.port || @vm.driver.ssh_port(@vm.config.ssh.guest_port),
-        :username      => @vm.config.ssh.username,
-        :forward_agent => @vm.config.ssh.forward_agent,
-        :forward_x11   => @vm.config.ssh.forward_x11
-      }
-
-      # This can happen if no port is set and for some reason Vagrant
-      # can't detect an SSH port.
-      raise Errors::SSHPortNotDetected if !results[:port]
-
-      # Determine the private key path, which is either set by the
-      # configuration or uses just the built-in insecure key.
-      pk_path = @vm.config.ssh.private_key_path || @vm.env.default_private_key_path
-      results[:private_key_path] = File.expand_path(pk_path, @vm.env.root_path)
-
-      # We need to check and fix the private key permissions
-      # to make sure that SSH gets a key with 0600 perms.
-      check_key_permissions(results[:private_key_path])
-
-      # Return the results
-      return results
-    end
-
-    # Connects to the environment's virtual machine, replacing the ruby
-    # process with an SSH process.
-    #
-    # @param [Hash] opts Options hash
-    # @options opts [Boolean] :plain_mode If True, doesn't authenticate with
-    #   the machine, only connects, allowing the user to connect.
-    def exec(opts={})
-      # Get the SSH information and cache it here
-      ssh_info = info
-
-      if Util::Platform.windows?
-        raise Errors::SSHUnavailableWindows, :host => ssh_info[:host],
-                                             :port => ssh_info[:port],
-                                             :username => ssh_info[:username],
-                                             :key_path => ssh_info[:private_key_path]
-      end
-
-      raise Errors::SSHUnavailable if !Kernel.system("which ssh > /dev/null 2>&1")
-
-      # If plain mode is enabled then we don't do any authentication (we don't
-      # set a user or an identity file)
-      plain_mode = opts[:plain_mode]
-
-      options = {}
-      options[:host] = ssh_info[:host]
-      options[:port] = ssh_info[:port]
-      options[:username] = ssh_info[:username]
-      options[:private_key_path] = ssh_info[:private_key_path]
-
-      # Command line options
-      command_options = ["-p", options[:port].to_s, "-o", "UserKnownHostsFile=/dev/null",
-                         "-o", "StrictHostKeyChecking=no", "-o", "LogLevel=ERROR"]
-
-      # Solaris/OpenSolaris/Illumos uses SunSSH which doesn't support the IdentitiesOnly option
-      command_options += ["-o", "IdentitiesOnly=yes"] unless Util::Platform.solaris?
-
-      command_options += ["-i", options[:private_key_path]] if !plain_mode
-      command_options += ["-o", "ForwardAgent=yes"] if ssh_info[:forward_agent]
-
-      # If there are extra options, then we append those
-      command_options.concat(opts[:extra_args]) if opts[:extra_args]
-
-      if ssh_info[:forward_x11]
-        # Both are required so that no warnings are shown regarding X11
-        command_options += ["-o", "ForwardX11=yes"]
-        command_options += ["-o", "ForwardX11Trusted=yes"]
-      end
-
-      host_string = options[:host]
-      host_string = "#{options[:username]}@#{host_string}" if !plain_mode
-      command_options << host_string
-      @logger.info("Invoking SSH: #{command_options.inspect}")
-      safe_exec("ssh", *command_options)
-    end
-
-    # Checks the file permissions for a private key, resetting them
-    # if needed.
-    def check_key_permissions(key_path)
-      # Windows systems don't have this issue
-      return if Util::Platform.windows?
-
-      @logger.debug("Checking key permissions: #{key_path}")
-      stat = File.stat(key_path)
-
-      if stat.owned? && Util::FileMode.from_octal(stat.mode) != "600"
-        @logger.info("Attempting to correct key permissions to 0600")
-        File.chmod(0600, key_path)
-
-        if Util::FileMode.from_octal(stat.mode) != "600"
-          raise Errors::SSHKeyBadPermissions, :key_path => key_path
-        end
-      end
-    rescue Errno::EPERM
-      # This shouldn't happen since we verified we own the file, but
-      # it is possible in theory, so we raise an error.
-      raise Errors::SSHKeyBadPermissions, :key_path => key_path
-    end
-  end
-end

data/lib/vagrant/test_helpers.rb

@@ -1,154 +0,0 @@
-module Vagrant
-  # Test helpers provided by Vagrant to allow for plugin developers
-  # to write automated tests for their code. This module simply provides
-  # methods which can be included into any test framework (`test/unit`,
-  # RSpec, Shoulda, etc.)
-  module TestHelpers
-    #------------------------------------------------------------
-    # Environment creation helpers
-    #------------------------------------------------------------
-    # Creates a "vagrant_app" directory in the test tmp folder
-    # which can be used for creating test Vagrant environments.
-    # Returns the root directory of the app. This typically doesn't need
-    # to be called directly unless you're setting up a custom application.
-    # See the examples for common use cases.
-    def vagrant_app(*path)
-      root = tmp_path.join("vagrant_app")
-      FileUtils.rm_rf(root)
-      FileUtils.mkdir_p(root)
-      root.join(*path)
-    end
-
-    # Creates a Vagrantfile with the given contents in the given
-    # app directory. If no app directory is specified, then a default
-    # Vagrant app is used.
-    def vagrantfile(*args)
-      path = args.shift.join("Vagrantfile") if Pathname === args.first
-      path ||= vagrant_app("Vagrantfile")
-
-      # Create this box so that it exists
-      vagrant_box("base")
-
-      str  = args.shift || ""
-      File.open(path.to_s, "w") do |f|
-        f.puts "ENV['VAGRANT_HOME'] = '#{home_path}'"
-        f.puts "Vagrant::Config.run do |config|"
-        f.puts "config.vm.base_mac = 'foo' if !config.vm.base_mac"
-        f.puts "config.vm.box = 'base'"
-        f.puts str
-        f.puts "end"
-      end
-
-      path.parent
-    end
-
-    # Creates and _loads_ a Vagrant environment at the given path.
-    # If no path is given, then a default {#vagrantfile} is used.
-    def vagrant_env(*args)
-      path = args.shift if Pathname === args.first
-      path ||= vagrantfile
-      Vagrant::Environment.new(:cwd => path).load!
-    end
-
-    # Creates the folder to contain a vagrant box. This allows for
-    # "fake" boxes to be made with the specified name.
-    #
-    # @param [String] name
-    # @return [Pathname]
-    def vagrant_box(name)
-      result = boxes_path.join(name)
-      FileUtils.mkdir_p(result)
-      result
-    end
-
-    # Returns an instantiated downloader with a mocked tempfile
-    # which can be passed into it.
-    #
-    # @param [Class] klass The downloader class
-    # @return [Array] Returns an array of `downloader` `tempfile`
-    def vagrant_mock_downloader(klass)
-      tempfile = mock("tempfile")
-      tempfile.stubs(:write)
-
-      _, env = action_env
-      [klass.new(env), tempfile]
-    end
-
-    # Returns a blank app (callable) and action environment with the
-    # given vagrant environment. This allows for testing of middlewares.
-    def action_env(v_env = nil)
-      v_env ||= vagrant_env
-      # duplicate the Vagrant::Environment ui and get the default vm object
-      # for the new action environment from the first pair in the vms list
-      opts = {:ui => v_env.ui.dup, :vm => v_env.vms.first.last}
-      app = lambda { |env| }
-      env = Vagrant::Action::Environment.new(opts)
-      env["vagrant.test"] = true
-      [app, env]
-    end
-
-    # Utility method for capturing output streams.
-    # @example Evaluate the output
-    #   output = capture(:stdout){ env.cli("foo") }
-    #   assert_equal "bar", output
-    # @example Silence the output
-    #   silence(:stdout){ env.cli("init") }
-    # @param [:stdout, :stderr] stream The stream to capture
-    # @yieldreturn String
-    # @see https://github.com/wycats/thor/blob/master/spec/spec_helper.rb
-    def capture(stream)
-      begin
-        stream = stream.to_s
-        eval "$#{stream} = StringIO.new"
-        yield
-        result = eval("$#{stream}").string
-      ensure
-        eval("$#{stream} = #{stream.upcase}")
-      end
-
-      result
-    end
-    alias :silence :capture
-
-    #------------------------------------------------------------
-    # Path helpers
-    #------------------------------------------------------------
-    # Path to the tmp directory for the tests.
-    #
-    # @return [Pathname]
-    def tmp_path
-      result = Vagrant.source_root.join("test", "tmp")
-      FileUtils.mkdir_p(result)
-      result
-    end
-
-    # Path to the "home" directory for the tests
-    #
-    # @return [Pathname]
-    def home_path
-      result = tmp_path.join("home")
-      FileUtils.mkdir_p(result)
-      result
-    end
-
-    # Path to the boxes directory in the home directory
-    #
-    # @return [Pathname]
-    def boxes_path
-      result = home_path.join("boxes")
-      FileUtils.mkdir_p(result)
-      result
-    end
-
-    # Cleans all the test temp paths, which includes the boxes path,
-    # home path, etc. This allows for cleaning between tests.
-    def clean_paths
-      FileUtils.rm_rf(tmp_path)
-
-      # Call these methods only to rebuild the directories
-      tmp_path
-      home_path
-      boxes_path
-    end
-  end
-end

data/lib/vagrant/vm.rb

@@ -1,195 +0,0 @@
-require 'log4r'
-
-module Vagrant
-  class VM
-    include Vagrant::Util
-
-    attr_reader :uuid
-    attr_reader :env
-    attr_reader :name
-    attr_reader :vm
-    attr_reader :box
-    attr_reader :config
-    attr_reader :driver
-
-    def initialize(name, env, config, opts=nil)
-      @logger = Log4r::Logger.new("vagrant::vm")
-
-      @name   = name
-      @vm     = nil
-      @env    = env
-      @config = config
-      @box    = env.boxes.find(config.vm.box)
-
-      opts ||= {}
-      if opts[:base]
-        # The name is the ID we use.
-        @uuid = name
-      else
-        # Load the UUID if its saved.
-        active = env.local_data[:active] || {}
-        @uuid = active[@name.to_s]
-      end
-
-      # Reload ourselves to get the state
-      reload!
-
-      # Load the associated guest.
-      load_guest!
-      @loaded_guest_distro = false
-    end
-
-    # Loads the guest associated with the VM. The guest class is
-    # responsible for OS-specific functionality. More information
-    # can be found by reading the documentation on {Vagrant::Guest::Base}.
-    #
-    # **This method should never be called manually.**
-    def load_guest!(guest=nil)
-      guest ||= config.vm.guest
-      @logger.info("Loading guest: #{guest}")
-
-      if guest.is_a?(Class)
-        raise Errors::VMGuestError, :_key => :invalid_class, :guest => guest.to_s if !(guest <= Guest::Base)
-        @guest = guest.new(self)
-      elsif guest.is_a?(Symbol)
-        guest_klass = Vagrant.guests.get(guest)
-        raise Errors::VMGuestError, :_key => :unknown_type, :guest => guest.to_s if !guest_klass
-        @guest = guest_klass.new(self)
-      else
-        raise Errors::VMGuestError, :unspecified
-      end
-    end
-
-    # Returns a channel object to communicate with the virtual
-    # machine.
-    def channel
-      @channel ||= Communication::SSH.new(self)
-    end
-
-    # Returns the guest for this VM, loading the distro of the system if
-    # we can.
-    def guest
-      if !@loaded_guest_distro && state == :running
-        # Load the guest distro for the first time
-        result = @guest.distro_dispatch
-        load_guest!(result)
-        @loaded_guest_distro = true
-      end
-
-      @guest
-    end
-
-    # Access the {Vagrant::SSH} object associated with this VM, which
-    # is used to get SSH credentials with the virtual machine.
-    def ssh
-      @ssh ||= SSH.new(self)
-    end
-
-    # Returns the state of the VM as a symbol.
-    #
-    # @return [Symbol]
-    def state
-      return :not_created if !@uuid
-      state = @driver.read_state
-      return :not_created if !state
-      return state
-    end
-
-    # Returns a boolean true if the VM has been created, otherwise
-    # returns false.
-    #
-    # @return [Boolean]
-    def created?
-      state != :not_created
-    end
-
-    # Sets the currently active VM for this VM. If the VM is a valid,
-    # created virtual machine, then it will also update the local data
-    # to persist the VM. Otherwise, it will remove itself from the
-    # local data (if it exists).
-    def uuid=(value)
-      env.local_data[:active] ||= {}
-      if value
-        env.local_data[:active][name.to_s] = value
-      else
-        env.local_data[:active].delete(name.to_s)
-      end
-
-      # Commit the local data so that the next time vagrant is initialized,
-      # it realizes the VM exists
-      env.local_data.commit
-
-      # Store the uuid and reload the instance
-      @uuid = value
-      reload!
-    end
-
-    def reload!
-      begin
-        @driver = Driver::VirtualBox.new(@uuid)
-      rescue Driver::VirtualBox::VMNotFound
-        # Clear the UUID since this VM doesn't exist.
-        @uuid = nil
-
-        # Reset the driver. This shouldn't raise a VMNotFound since we won't
-        # feed it a UUID.
-        @driver = Driver::VirtualBox.new
-      end
-    end
-
-    def package(options=nil)
-      run_action(:package, { "validate" => false }.merge(options || {}))
-    end
-
-    def up(options=nil)
-      run_action(:up, options)
-    end
-
-    def start(options=nil)
-      return if state == :running
-      return resume if state == :saved
-
-      run_action(:start, options)
-    end
-
-    def halt(options=nil)
-      run_action(:halt, options)
-    end
-
-    def reload(options=nil)
-      run_action(:reload, options)
-    end
-
-    def provision
-      run_action(:provision)
-    end
-
-    def destroy
-      run_action(:destroy)
-    end
-
-    def suspend
-      run_action(:suspend)
-    end
-
-    def resume
-      run_action(:resume)
-    end
-
-    def ui
-      return @_ui if defined?(@_ui)
-      @_ui = @env.ui.dup
-      @_ui.resource = @name
-      @_ui
-    end
-
-    def run_action(name, options=nil)
-      options = {
-        :vm => self,
-        :ui => ui
-      }.merge(options || {})
-
-      env.action_runner.run(name, options)
-    end
-  end
-end

data/templates/guests/arch/network_dhcp.erb

@@ -1,7 +0,0 @@
-#VAGRANT-BEGIN
-# The contents below are automatically generated by Vagrant. Do not modify.
-interface=eth<%= options[:interface] %>
-address=
-netmask=
-gateway=
-#VAGRANT-END

data/templates/guests/arch/network_static.erb

@@ -1,7 +0,0 @@
-#VAGRANT-BEGIN
-# The contents below are automatically generated by Vagrant. Do not modify.
-interface=eth<%= options[:interface] %>
-address=<%= options[:ip]%>
-netmask=<%= options[:netmask] %>
-gateway=
-#VAGRANT-END

data/templates/guests/fedora/network_dhcp.erb

@@ -1,6 +0,0 @@
-#VAGRANT-BEGIN
-# The contents below are automatically generated by Vagrant. Do not modify.
-BOOTPROTO=dhcp
-ONBOOT=yes
-DEVICE=p7p<%= options[:interface] %>
-#VAGRANT-END

data/templates/guests/fedora/network_static.erb

@@ -1,13 +0,0 @@
-#VAGRANT-BEGIN
-# The contents below are automatically generated by Vagrant. Do not modify.
-NM_CONTROLLED=no
-BOOTPROTO=static
-ONBOOT=yes
-IPADDR=<%= options[:ip] %>
-NETMASK=<%= options[:netmask] %>
-DEVICE=p7p<%= options[:interface] %>
-<%= options[:gateway] ? "GATEWAY=#{options[:gateway]}" : '' %>
-<%= options[:mac_address] ? "HWADDR=#{options[:mac_address]}" : '' %>
-<%= options[:dns1] ? "DNS1=#{options[:dns1]}" : 'DNS1=8.8.4.4' %>
-<%= options[:dns2] ? "DNS2=#{options[:dns2]}" : 'DNS1=8.8.8.8' %>
-#VAGRANT-END

data/templates/nfs/exports.erb

@@ -1,5 +0,0 @@
-# VAGRANT-BEGIN: <%= uuid %>
-<% folders.each do |name, opts| %>
-"<%= opts[:hostpath] %>" <%= ip %><% if opts[:map_uid] -%> -mapall=<%= [opts[:map_uid],opts[:map_gid]].compact.join(":") %><% end -%>
-<% end %>
-# VAGRANT-END: <%= uuid %>

data/templates/nfs/exports_freebsd.erb

@@ -1,5 +0,0 @@
-# VAGRANT-BEGIN: <%= uuid %>
-<% folders.each do |name, opts| %>
-<%= opts[:hostpath] %> <%= ip %><% if opts[:map_uid] -%> -alldirs -mapall=<%= [opts[:map_uid],opts[:map_gid]].compact.join(":") %><% end -%>
-<% end %>
-# VAGRANT-END: <%= uuid %>

data/test/acceptance/base.rb

@@ -1,48 +0,0 @@
-require "rubygems"
-require "rspec/autorun"
-
-require "log4r"
-
-# Add the test directory to the load path
-$:.unshift File.expand_path("../../", __FILE__)
-
-# Load in the supporting files for our tests
-require "acceptance/support/shared/base_context"
-require "acceptance/support/config"
-require "acceptance/support/virtualbox"
-require "acceptance/support/matchers/match_output"
-require "acceptance/support/matchers/succeed"
-
-# Do not buffer output
-$stdout.sync = true
-$stderr.sync = true
-
-# If VirtualBox is currently running, fail.
-if Acceptance::VirtualBox.find_vboxsvc
-  $stderr.puts "VirtualBox must be closed and remain closed for the duration of the tests."
-  abort
-end
-
-# Enable logging if requested
-if ENV["ACCEPTANCE_LOG"]
-  logger = Log4r::Logger.new("test")
-  logger.outputters = Log4r::Outputter.stdout
-  logger.level = Log4r.const_get(ENV["ACCEPTANCE_LOG"].upcase)
-  logger = nil
-end
-
-# Parse the command line options and load the global configuration.
-if !ENV.has_key?("ACCEPTANCE_CONFIG")
-  $stderr.puts "A configuration file must be passed into the acceptance test."
-  abort
-elsif !File.file?(ENV["ACCEPTANCE_CONFIG"])
-  $stderr.puts "The configuration file must exist."
-  abort
-end
-
-$acceptance_options = Acceptance::Config.new(ENV["ACCEPTANCE_CONFIG"])
-
-# Configure RSpec
-RSpec.configure do |c|
-  c.expect_with :rspec, :stdlib
-end