vagrantup 0.8.10 → 0.9.0

data/lib/vagrant/command/up.rb

@@ -1,16 +1,49 @@
+require 'optparse'
+
 module Vagrant
   module Command
-    class UpCommand < NamedBase
-      class_option :provision, :type => :boolean, :default => true
-      register "up", "Creates the Vagrant environment"
-
+    class Up < Base
       def execute
-        target_vms.each do |vm|
+        options = {
+          :provision => true,
+          :provisioners => nil
+        }
+
+        opts = OptionParser.new do |opts|
+          opts.banner = "Usage: vagrant up [vm-name] [--[no-]provision] [-h]"
+
+          opts.separator ""
+
+          opts.on("--[no-]provision", "Enable or disable provisioning") do |p|
+            options[:provision] = p
+          end
+
+          opts.on("--provision-with x,y,z", Array,
+                  "Enable only certain provisioners, by type.") do |list|
+            options[:provisioners] = list
+          end
+        end
+
+        # Parse the options
+        argv = parse_options(opts)
+        return if !argv
+
+        # Parameters to send to actions
+        action_params = {
+          "provision.enabled" => options[:provision],
+          "provision.types"   => options[:provisioners]
+        }
+
+        # Go over each VM and bring it up
+        @logger.debug("'Up' each target VM...")
+        with_target_vms(argv[0]) do |vm|
           if vm.created?
-            vm.env.ui.info I18n.t("vagrant.commands.up.vm_created")
-            vm.start("provision.enabled" => options[:provision])
+            @logger.info("Booting: #{vm.name}")
+            vm.ui.info I18n.t("vagrant.commands.up.vm_created")
+            vm.start(action_params)
           else
-            vm.up("provision.enabled" => options[:provision])
+            @logger.info("Creating: #{vm.name}")
+            vm.up(action_params)
           end
         end
       end

data/lib/vagrant/command.rb

@@ -1,25 +1,23 @@
 module Vagrant
   module Command
     autoload :Base,      'vagrant/command/base'
-    autoload :GroupBase, 'vagrant/command/group_base'
-    autoload :Helpers,   'vagrant/command/helpers'
-    autoload :NamedBase, 'vagrant/command/named_base'
+
+    autoload :Box,          'vagrant/command/box'
+    autoload :BoxAdd,       'vagrant/command/box_add'
+    autoload :BoxRemove,    'vagrant/command/box_remove'
+    autoload :BoxRepackage, 'vagrant/command/box_repackage'
+    autoload :BoxList,      'vagrant/command/box_list'
+    autoload :Destroy,      'vagrant/command/destroy'
+    autoload :Halt,         'vagrant/command/halt'
+    autoload :Init,         'vagrant/command/init'
+    autoload :Package,      'vagrant/command/package'
+    autoload :Provision,    'vagrant/command/provision'
+    autoload :Reload,       'vagrant/command/reload'
+    autoload :Resume,       'vagrant/command/resume'
+    autoload :SSH,          'vagrant/command/ssh'
+    autoload :SSHConfig,    'vagrant/command/ssh_config'
+    autoload :Status,       'vagrant/command/status'
+    autoload :Suspend,      'vagrant/command/suspend'
+    autoload :Up,           'vagrant/command/up'
   end
 end
-
-# The built-in commands must always be loaded
-require 'vagrant/command/box'
-require 'vagrant/command/destroy'
-require 'vagrant/command/halt'
-require 'vagrant/command/init'
-require 'vagrant/command/package'
-require 'vagrant/command/provision'
-require 'vagrant/command/reload'
-require 'vagrant/command/resume'
-require 'vagrant/command/ssh'
-require 'vagrant/command/ssh_config'
-require 'vagrant/command/status'
-require 'vagrant/command/suspend'
-require 'vagrant/command/up'
-require 'vagrant/command/upgrade_to_060'
-require 'vagrant/command/version'

data/lib/vagrant/communication/base.rb

@@ -0,0 +1,56 @@
+module Vagrant
+  module Communication
+    # The base class for any classes that provide an API for communicating
+    # with the virtual machine.
+    #
+    # There are various stages that require Vagrant to copy files or
+    # run commands on the target system, and communication classes provide
+    # the abstraction necessary to perform these tasks, via SSH or some
+    # other mechanism.
+    #
+    # Any subclasses of this class **must** implement all of the methods
+    # below.
+    class Base
+      # Checks if the target machine is ready for communication.
+      #
+      # @return [Boolean]
+      def ready?
+      end
+
+      # Upload a file to the virtual machine.
+      #
+      # @param [String] from Path to a file to upload.
+      # @param [String] to Path to where to save this file.
+      def upload(from, to)
+      end
+
+      # Execute a command on the remote machine.
+      #
+      # @param [String] command Command to execute.
+      # @yield [type, data] Realtime output of the command being executed.
+      # @yieldparam [String] type Type of the output, `:stdout`, `:stderr`, etc.
+      # @yieldparam [String] data Data for the given output.
+      # @return [Integer] Exit code of the command.
+      def execute(command, opts=nil)
+      end
+
+      # Execute a comand with super user privileges.
+      #
+      # See #execute for parameter information.
+      def sudo(command, opts=nil)
+      end
+
+      # Executes a command and returns a boolean statement if it was successful
+      # or not.
+      #
+      # This is implemented by default as expecting `execute` to return 0.
+      def test(command, opts=nil)
+        # Disable error checking no matter what
+        opts = (opts || {}).merge(:error_check => false)
+
+        # Successful if the exit status is 0
+        execute(command, opts) == 0
+      end
+    end
+  end
+end

data/lib/vagrant/communication/ssh.rb

@@ -0,0 +1,200 @@
+require 'timeout'
+
+require 'log4r'
+require 'net/ssh'
+require 'net/scp'
+
+require 'vagrant/util/file_mode'
+require 'vagrant/util/platform'
+require 'vagrant/util/retryable'
+
+module Vagrant
+  module Communication
+    # Provides communication with the VM via SSH.
+    class SSH < Base
+      include Util::Retryable
+
+      def initialize(vm)
+        @vm     = vm
+        @logger = Log4r::Logger.new("vagrant::communication::ssh")
+        @connection = nil
+      end
+
+      def ready?
+        @logger.debug("Checking whether SSH is ready...")
+
+        Timeout.timeout(@vm.config.ssh.timeout) do
+          connect
+        end
+
+        # If we reached this point then we successfully connected
+        @logger.info("SSH is ready!")
+        true
+      rescue Timeout::Error, Errors::SSHConnectionRefused, Net::SSH::Disconnect => e
+        # The above errors represent various reasons that SSH may not be
+        # ready yet. Return false.
+        @logger.info("SSH not up: #{e.inspect}")
+        return false
+      end
+
+      def execute(command, opts=nil, &block)
+        opts = {
+          :error_check => true,
+          :error_class => Errors::VagrantError,
+          :error_key   => :ssh_bad_exit_status,
+          :command     => command,
+          :sudo        => false
+        }.merge(opts || {})
+
+        # Connect via SSH and execute the command in the shell.
+        exit_status = connect do |connection|
+          shell_execute(connection, command, opts[:sudo], &block)
+        end
+
+        # Check for any errors
+        if opts[:error_check] && exit_status != 0
+          # The error classes expect the translation key to be _key,
+          # but that makes for an ugly configuration parameter, so we
+          # set it here from `error_key`
+          error_opts = opts.merge(:_key => opts[:error_key])
+          raise opts[:error_class], error_opts
+        end
+
+        # Return the exit status
+        exit_status
+      end
+
+      def sudo(command, opts=nil, &block)
+        # Run `execute` but with the `sudo` option.
+        opts = { :sudo => true }.merge(opts || {})
+        execute(command, opts, &block)
+      end
+
+      def upload(from, to)
+        # Do an SCP-based upload...
+        connect do |connection|
+          scp = Net::SCP.new(connection)
+          scp.upload!(from, to)
+        end
+      rescue Net::SCP::Error => e
+        # If we get the exit code of 127, then this means SCP is unavailable.
+        raise Errors::SCPUnavailable if e.message =~ /\(127\)/
+
+        # Otherwise, just raise the error up
+        raise
+      end
+
+      protected
+
+      # Opens an SSH connection and yields it to a block.
+      def connect
+        if @connection && !@connection.closed?
+          # There is a chance that the socket is closed despite us checking
+          # 'closed?' above. To test this we need to send data through the
+          # socket.
+          begin
+            @connection.exec!("")
+          rescue IOError
+            @logger.info("Connection has been closed. Not re-using.")
+            @connection = nil
+          end
+
+          # If the @connection is still around, then it is valid,
+          # and we use it.
+          if @connection
+            @logger.info("Re-using SSH connection.")
+            return yield @connection if block_given?
+            return
+          end
+        end
+
+        ssh_info = @vm.ssh.info
+
+        # Build the options we'll use to initiate the connection via Net::SSH
+        opts = {
+          :port                  => ssh_info[:port],
+          :keys                  => [ssh_info[:private_key_path]],
+          :keys_only             => true,
+          :user_known_hosts_file => [],
+          :paranoid              => false,
+          :config                => false,
+          :forward_agent         => ssh_info[:forward_agent]
+        }
+
+        # Check that the private key permissions are valid
+        @vm.ssh.check_key_permissions(ssh_info[:private_key_path])
+
+        # Connect to SSH, giving it a few tries
+        @logger.info("Connecting to SSH: #{ssh_info[:host]}:#{ssh_info[:port]}")
+        exceptions = [Errno::ECONNREFUSED, Net::SSH::Disconnect]
+        connection = retryable(:tries => @vm.config.ssh.max_tries, :on => exceptions) do
+          Net::SSH.start(ssh_info[:host], ssh_info[:username], opts)
+        end
+
+        @connection = connection
+
+        # This is hacky but actually helps with some issues where
+        # Net::SSH is simply not robust enough to handle... see
+        # issue #391, #455, etc.
+        sleep 4
+
+        # Yield the connection that is ready to be used and
+        # return the value of the block
+        return yield connection if block_given?
+      rescue Net::SSH::AuthenticationFailed
+        # This happens if authentication failed. We wrap the error in our
+        # own exception.
+        raise Errors::SSHAuthenticationFailed
+      rescue Errno::ECONNREFUSED
+        # This is raised if we failed to connect the max amount of times
+        raise Errors::SSHConnectionRefused
+      ensure
+        # Be sure the connection is always closed
+        # connection.close if connection && !connection.closed?
+      end
+
+      # Executes the command on an SSH connection within a login shell.
+      def shell_execute(connection, command, sudo=false)
+        exit_status = nil
+
+        # Determine the shell to execute. If we are using `sudo` then we
+        # need to wrap the shell in a `sudo` call.
+        shell = "#{@vm.config.ssh.shell} -l"
+        shell = "sudo -H #{shell}" if sudo
+
+        # Open the channel so we can execute or command
+        channel = connection.open_channel do |ch|
+          ch.exec(shell) do |ch2, _|
+            # Setup the channel callbacks so we can get data and exit status
+            ch2.on_data do |ch3, data|
+              yield :stdout, data if block_given?
+            end
+
+            ch2.on_extended_data do |ch3, type, data|
+              yield :stderr, data if block_given?
+            end
+
+            ch2.on_request("exit-status") do |ch3, data|
+              exit_status = data.read_long
+            end
+
+            # Set the terminal
+            ch2.send_data "export TERM=vt100\n"
+
+            # Output the command
+            ch2.send_data "#{command}\n"
+
+            # Remember to exit or this channel will hang open
+            ch2.send_data "exit\n"
+          end
+        end
+
+        # Wait for the channel to complete
+        channel.wait
+
+        # Return the final exit status
+        return exit_status
+      end
+    end
+  end
+end

data/lib/vagrant/communication.rb

@@ -0,0 +1,7 @@
+module Vagrant
+  module Communication
+    autoload :Base, 'vagrant/communication/base'
+
+    autoload :SSH,  'vagrant/communication/ssh'
+  end
+end

data/lib/vagrant/config/base.rb

@@ -1,22 +1,9 @@
 module Vagrant
-  class Config
+  module Config
     # The base class for all configuration classes. This implements
     # basic things such as the environment instance variable which all
     # config classes need as well as a basic `to_json` implementation.
     class Base
-      # {Top} of this configuration stack
-      attr_accessor :top
-
-      # Registers a subclass with the Vagrant configuration system so
-      # that it can then be used in Vagrantfiles.
-      #
-      # @param [Symbol] accessor The accessor on the main config object
-      #  that is used to access the configuration class.
-      #
-      def self.configures(accessor, klass=self)
-        Top.configures(accessor, klass)
-      end
-
       # Loads configuration values from JSON back into the proper
       # configuration classes. By default, this is done by simply
       # iterating over all values in the JSON hash and assigning them
@@ -29,14 +16,6 @@ module Vagrant
         end
       end
 
-      # A helper to access the environment that this configuration is for.
-      # This is obtained by getting the env from the {Top}.
-      #
-      # @return [Vagrant::Envrionment]
-      def env
-        top.env
-      end
-
       # Allows setting options from a hash. By default this simply calls
       # the `#{key}=` method on the config class with the value, which is
       # the expected behavior most of the time.
@@ -46,12 +25,26 @@ module Vagrant
         end
       end
 
+      # Merge another configuration object into this one.
+      #
+      # @param [Object] other The other configuration object to merge from,
+      #   this must be the same type of object as this one.
+      # @return [Object] The merged object.
+      def merge(other)
+        result = self.class.new
+        instance_variables_hash.merge(other.instance_variables_hash).each do |key, value|
+          result.instance_variable_set("@#{key}".to_sym, value)
+        end
+
+        result
+      end
+
       # Called by {Top} after the configuration is loaded to validate
       # the configuaration objects. Subclasses should implement this
       # method and add any errors to the `errors` object given.
       #
       # @param [ErrorRecorder] errors
-      def validate(errors); end
+      def validate(env, errors); end
 
       # Converts the configuration to a raw hash by calling `#to_hash`
       # on all instance variables (if it can) and putting them into
@@ -69,14 +62,13 @@ module Vagrant
       # the JSON is parsed back, it can be loaded back into the proper class.
       # See {json_create}.
       def to_json(*a)
-        result = { 'json_class' => self.class.name }
-        result.merge(instance_variables_hash).to_json(*a)
+        instance_variables_hash.to_json(*a)
       end
 
       # Returns the instance variables as a hash of key-value pairs.
       def instance_variables_hash
         instance_variables.inject({}) do |acc, iv|
-          acc[iv.to_s[1..-1]] = instance_variable_get(iv) unless [:@env, :@top].include?(iv.to_sym)
+          acc[iv.to_s[1..-1]] = instance_variable_get(iv)
           acc
         end
       end

data/lib/vagrant/config/container.rb

@@ -0,0 +1,37 @@
+module Vagrant
+  module Config
+    # Contains loaded configuration values and provides access to those
+    # values.
+    #
+    # This is the class returned when loading configuration and stores
+    # the completely loaded configuration values. This class is meant to
+    # be immutable.
+    class Container
+      attr_reader :global
+      attr_reader :vms
+
+      # Initializes the configuration container.
+      #
+      # @param [Top] global Top-level configuration for the global
+      #   applicatoin.
+      # @param [Array] vms Array of VM configurations.
+      def initialize(global, vms)
+        @global = global
+        @vms    = []
+        @vm_configs = {}
+
+        vms.each do |vm_config|
+          @vms << vm_config.vm.name
+          @vm_configs[vm_config.vm.name] = vm_config
+        end
+      end
+
+      # This returns the configuration for a specific virtual machine.
+      # The values for this configuration are usually pertinent to a
+      # single virtual machine and do not affect the system globally.
+      def for_vm(name)
+        @vm_configs[name]
+      end
+    end
+  end
+end

data/lib/vagrant/config/error_recorder.rb

@@ -1,5 +1,5 @@
 module Vagrant
-  class Config
+  module Config
     # A class which is passed into the various {Base#validate} methods and
     # can be used as a helper to add error messages about a single config
     # class.

data/lib/vagrant/config/loader.rb

@@ -0,0 +1,125 @@
+require "pathname"
+
+require "log4r"
+
+module Vagrant
+  module Config
+    # This class is responsible for loading Vagrant configuration,
+    # usually in the form of Vagrantfiles.
+    #
+    # Loading works by specifying the sources for the configuration
+    # as well as the order the sources should be loaded. Configuration
+    # set later always overrides those set earlier; this is how
+    # configuration "scoping" is implemented.
+    class Loader
+      # This is an array of symbols specifying the order in which
+      # configuration is loaded. For examples, see the class documentation.
+      attr_accessor :load_order
+
+      def initialize
+        @logger  = Log4r::Logger.new("vagrant::config::loader")
+        @sources = {}
+        @proc_cache = {}
+        @config_cache = {}
+      end
+
+      # Set the configuration data for the given name.
+      #
+      # The `name` should be a symbol and must uniquely identify the data
+      # being given.
+      #
+      # `data` can either be a path to a Ruby Vagrantfile or a `Proc` directly.
+      # `data` can also be an array of such values.
+      #
+      # At this point, no configuration is actually loaded. Note that calling
+      # `set` multiple times with the same name will override any previously
+      # set values. In this way, the last set data for a given name wins.
+      def set(name, sources)
+        @logger.debug("Set #{name.inspect} = #{sources.inspect}")
+
+        # Sources should be an array
+        sources = [sources] if !sources.kind_of?(Array)
+
+        # Gather the procs for every source, since that is what we care about.
+        procs = []
+        sources.each do |source|
+          if !@proc_cache.has_key?(source)
+            # Load the procs for this source and cache them. This caching
+            # avoids the issue where a file may have side effects when loading
+            # and loading it multiple times causes unexpected behavior.
+            @logger.debug("Populating proc cache for #{source.inspect}")
+            @proc_cache[source] = procs_for_source(source)
+          end
+
+          # Add on to the array of procs we're going to use
+          procs.concat(@proc_cache[source])
+        end
+
+        # Set this source by name.
+        @sources[name] = procs
+      end
+
+      # This loads the configured sources in the configured order and returns
+      # an actual configuration object that is ready to be used.
+      def load
+        @logger.debug("Loading configuration in order: #{@load_order.inspect}")
+
+        unknown_sources = @sources.keys - @load_order
+        if !unknown_sources.empty?
+          # TODO: Raise exception here perhaps.
+          @logger.error("Unknown config sources: #{unknown_sources.inspect}")
+        end
+
+        # Create the top-level configuration which will hold all the config.
+        result = Top.new
+
+        @load_order.each do |key|
+          next if !@sources.has_key?(key)
+
+          @sources[key].each do |proc|
+            if !@config_cache.has_key?(proc)
+              @logger.debug("Loading from: #{key} (evaluating)")
+              current = Top.new
+              proc.call(current)
+              @config_cache[proc] = current
+            end
+
+            # Merge in the results of this proc's configuration
+            result = result.merge(@config_cache[proc])
+          end
+        end
+
+        @logger.debug("Configuration loaded successfully")
+        result
+      end
+
+      protected
+
+      # This returns an array of `Proc` objects for the given source.
+      # The `Proc` objects returned will expect a single argument for
+      # the configuration object and are expected to mutate this
+      # configuration object.
+      def procs_for_source(source)
+        return [source] if source.is_a?(Proc)
+
+        # Assume all string sources are actually pathnames
+        source = Pathname.new(source) if source.is_a?(String)
+
+        if source.is_a?(Pathname)
+          @logger.debug("Load procs for pathname: #{source.inspect}")
+
+          begin
+            return Config.capture_configures do
+              Kernel.load source
+            end
+          rescue SyntaxError => e
+            # Report syntax errors in a nice way.
+            raise Errors::VagrantfileSyntaxError, :file => e.message
+          end
+        end
+
+        raise Exception, "Unknown configuration source: #{source.inspect}"
+      end
+    end
+  end
+end

data/lib/vagrant/config/nfs.rb

@@ -1,8 +1,6 @@
 module Vagrant
-  class Config
+  module Config
     class NFSConfig < Base
-      configures :nfs
-
       attr_accessor :map_uid
       attr_accessor :map_gid
     end

data/lib/vagrant/config/package.rb

@@ -1,8 +1,6 @@
 module Vagrant
-  class Config
+  module Config
     class PackageConfig < Base
-      configures :package
-
       attr_accessor :name
     end
   end