vagrantup 0.5.4 → 0.6.0

data/lib/vagrant/command/ssh.rb

@@ -0,0 +1,41 @@
+module Vagrant
+  module Command
+    class SSHCommand < NamedBase
+      class_option :execute, :type => :string, :default => false, :aliases => "-e"
+      register "ssh", "SSH into the currently running Vagrant environment."
+
+      def execute
+        if options[:execute]
+          ssh_execute
+        else
+          ssh_connect
+        end
+      end
+
+      protected
+
+      def ssh_execute
+        ssh_vm.ssh.execute do |ssh|
+          ssh_vm.env.ui.info I18n.t("vagrant.commands.ssh.execute", :command => options[:execute])
+          ssh.exec!(options[:execute]) do |channel, type, data|
+            ssh_vm.env.ui.info "#{data}"
+          end
+        end
+      end
+
+      def ssh_connect
+        raise VMNotCreatedError.new if !ssh_vm.created?
+        ssh_vm.ssh.connect
+      end
+
+      def ssh_vm
+        @ssh_vm ||= begin
+          vm = self.name.nil? && env.multivm? ? env.primary_vm : nil
+          raise MultiVMTargetRequired.new(:command => "ssh") if !vm && target_vms.length > 1
+          vm = target_vms.first if !vm
+          vm
+        end
+      end
+    end
+  end
+end

data/lib/vagrant/command/ssh_config.rb

@@ -0,0 +1,21 @@
+module Vagrant
+  module Command
+    class SSHConfigCommand < NamedBase
+      class_option :host, :type => :string, :default => nil, :aliases => "-h"
+      register "ssh_config", "outputs .ssh/config valid syntax for connecting to this environment via ssh"
+
+      def execute
+        raise MultiVMTargetRequired.new(:command => "ssh_config") if target_vms.length > 1
+        vm = target_vms.first
+        raise VMNotCreatedError.new if !vm.created?
+
+        env.ui.info(Util::TemplateRenderer.render("ssh_config", {
+          :host_key => options[:host] || "vagrant",
+          :ssh_user => vm.env.config.ssh.username,
+          :ssh_port => vm.ssh.port,
+          :private_key_path => vm.env.config.ssh.private_key_path
+        }), :prefix => false)
+      end
+    end
+  end
+end

data/lib/vagrant/command/status.rb

@@ -0,0 +1,23 @@
+module Vagrant
+  module Command
+    class StatusCommand < Base
+      argument :name, :type => :string, :optional => true
+      register "status", "Shows the status of the current Vagrant environment."
+
+      def route
+        state = nil
+        results = env.vms.collect do |name, vm|
+          state ||= vm.created? ? vm.vm.state.to_s : "not_created"
+          "#{name.to_s.ljust(25)}#{state.gsub("_", " ")}"
+        end
+
+        state = env.vms.length == 1 ? state : "listing"
+
+        env.ui.info(I18n.t("vagrant.commands.status.output",
+                    :states => results.join("\n"),
+                    :message => I18n.t("vagrant.commands.status.#{state}")),
+                    :prefix => false)
+      end
+    end
+  end
+end

data/lib/vagrant/command/suspend.rb

@@ -0,0 +1,17 @@
+module Vagrant
+  module Command
+    class SuspendCommand < NamedBase
+      register "suspend", "Suspend a running Vagrant environment."
+
+      def execute
+        target_vms.each do |vm|
+          if vm.created?
+            vm.suspend
+          else
+            vm.env.ui.info I18n.t("vagrant.commands.common.vm_not_created")
+          end
+        end
+      end
+    end
+  end
+end

data/lib/vagrant/command/up.rb

@@ -0,0 +1,20 @@
+module Vagrant
+  module Command
+    class UpCommand < NamedBase
+      class_option :provision, :type => :boolean, :default => true
+      register "up", "Creates the Vagrant environment"
+
+      def execute
+        # TODO: Make the options[:provision] actually mean something
+        target_vms.each do |vm|
+          if vm.created?
+            vm.env.ui.info I18n.t("vagrant.commands.up.vm_created")
+            vm.start
+          else
+            vm.up
+          end
+        end
+      end
+    end
+  end
+end

data/lib/vagrant/command/upgrade_to_060.rb

@@ -0,0 +1,45 @@
+require 'fileutils'
+
+module Vagrant
+  module Command
+    class UpgradeTo060Command < Base
+      register "upgrade_to_060", "Upgrade pre-0.6.0 environment to 0.6.0", :hide => true
+
+      def execute
+        @env.ui.warn I18n.t("vagrant.commands.upgrade_to_060.info"), :prefix => false
+        @env.ui.warn "", :prefix => false
+        if !@env.ui.yes? I18n.t("vagrant.commands.upgrade_to_060.ask"), :prefix => false, :color => :yellow
+          @env.ui.info I18n.t("vagrant.commands.upgrade_to_060.quit"), :prefix => false
+          return
+        end
+
+        local_data = @env.local_data
+        if !local_data.empty?
+          if local_data[:active]
+            @env.ui.confirm I18n.t("vagrant.commands.upgrade_to_060.already_done"), :prefix => false
+            return
+          end
+
+          # Backup the previous file
+          @env.ui.info I18n.t("vagrant.commands.upgrade_to_060.backing_up"), :prefix => false
+          FileUtils.cp(local_data.file_path, "#{local_data.file_path}.bak-#{Time.now.to_i}")
+
+          # Gather the previously set virtual machines into a single
+          # active hash
+          active = local_data.inject({}) do |acc, data|
+            key, uuid = data
+            acc[key.to_sym] = uuid
+            acc
+          end
+
+          # Set the active hash to the active list and save it
+          local_data.clear
+          local_data[:active] = active
+          local_data.commit
+        end
+
+        @env.ui.confirm I18n.t("vagrant.commands.upgrade_to_060.complete"), :prefix => false
+      end
+    end
+  end
+end

data/lib/vagrant/command/version.rb

@@ -0,0 +1,13 @@
+module Vagrant
+  module Command
+    class VersionCommand < Base
+      register "version", "Prints the Vagrant version information", :alias => %w(-v --version)
+
+      def version
+        env.ui.info(I18n.t("vagrant.commands.version.output",
+                    :version => Vagrant::VERSION),
+                    :prefix => false)
+      end
+    end
+  end
+end

data/lib/vagrant/config.rb

@@ -1,14 +1,42 @@
-module Vagrant
-  def self.config
-    Config.config
-  end
+require 'vagrant/config/base'
+require 'vagrant/config/error_recorder'
 
+module Vagrant
+  # The config class is responsible for loading Vagrant configurations, which
+  # are usually found in Vagrantfiles but may also be procs. The loading is done
+  # by specifying a queue of files or procs that are for configuration, and then
+  # executing them. The config loader will run each item in the queue, so that
+  # configuration from later items overwrite that from earlier items. This is how
+  # Vagrant "scoping" of Vagranfiles is implemented.
+  #
+  # If you're looking to create your own configuration classes, see {Base}.
+  #
+  # # Loading Configuration Files
+  #
+  # If you are in fact looking to load configuration files, then this is the
+  # class you are looking for. Loading configuration is quite easy. The following
+  # example assumes `env` is already a loaded instance of {Environment}:
+  #
+  #     config = Vagrant::Config.new(env)
+  #     config.queue << "/path/to/some/Vagrantfile"
+  #     result = config.load!
+  #
+  #     p "Your box is: #{result.vm.box}"
+  #
   class Config
     extend Util::StackedProcRunner
 
     @@config = nil
 
+    attr_reader :queue
+
     class << self
+      # Resets the current loaded config object to the specified environment.
+      # This clears the proc stack and initializes a new {Top} for loading.
+      # This method shouldn't be called directly, instead use an instance of this
+      # class for config loading.
+      #
+      # @param [Environment] env
       def reset!(env=nil)
         @@config = nil
         proc_stack.clear
@@ -17,216 +45,94 @@ module Vagrant
         config(env)
       end
 
-      def configures(key, klass)
-        config.class.configures(key, klass)
-      end
-
+      # Returns the current {Top} configuration object. While this is still
+      # here for implementation purposes, it shouldn't be called directly. Instead,
+      # use an instance of this class.
       def config(env=nil)
         @@config ||= Config::Top.new(env)
       end
 
+      # Adds the given proc/block to the stack of config procs which are all
+      # run later on a single config object. This is the main way to configure
+      # Vagrant, and is how all Vagrantfiles are formatted:
+      #
+      #     Vagrant::Config.run do |config|
+      #       # ...
+      #     end
+      #
       def run(&block)
         push_proc(&block)
       end
 
+      # Executes all the config procs onto the currently loaded {Top} object,
+      # and returns the final configured object. This also validates the
+      # configuration by calling {Top#validate!} on every configuration
+      # class.
       def execute!(config_object=nil)
         config_object ||= config
 
         run_procs!(config_object)
-        config_object.loaded!
+        config_object.validate!
         config_object
       end
     end
-  end
-
-  class Config
-    class Base
-      attr_accessor :env
 
-      def [](key)
-        send(key)
-      end
-
-      def to_json(*a)
-        instance_variables_hash.to_json(*a)
-      end
-
-      def instance_variables_hash
-        instance_variables.inject({}) do |acc, iv|
-          acc[iv.to_s[1..-1].to_sym] = instance_variable_get(iv) unless iv.to_sym == :@env
-          acc
-        end
-      end
+    # Initialize a {Config} object for the given {Environment}.
+    #
+    # @param [Environment] env Environment which config object will be part
+    #   of.
+    def initialize(env)
+      @env = env
+      @queue = []
     end
 
-    class SSHConfig < Base
-      attr_accessor :username
-      attr_accessor :host
-      attr_accessor :port
-      attr_accessor :forwarded_port_key
-      attr_accessor :max_tries
-      attr_accessor :timeout
-      attr_accessor :private_key_path
-      attr_accessor :forward_agent
-
-      # The attribute(s) below do nothing. They are just kept here to
-      # prevent syntax errors for backwards compat.
-      attr_accessor :password
-
-      def private_key_path
-        File.expand_path(@private_key_path, env.root_path)
-      end
-    end
-
-    class UnisonConfig < Base
-      attr_accessor :folder_suffix
-      attr_accessor :script
-      attr_accessor :options
-      attr_accessor :crontab_entry_file
-      attr_accessor :log_file
-    end
-
-    class NFSConfig < Base
-      attr_accessor :map_uid
-      attr_accessor :map_gid
-    end
-
-    class VMConfig < Base
-      include Util::StackedProcRunner
-
-      attr_accessor :auto_port_range
-      attr_accessor :box
-      attr_accessor :box_url
-      attr_accessor :box_ovf
-      attr_accessor :base_mac
-      attr_accessor :boot_mode
-      attr_reader :forwarded_ports
-      attr_reader :shared_folders
-      attr_reader :network_options
-      attr_accessor :hd_location
-      attr_accessor :disk_image_format
-      attr_accessor :provisioner
-      attr_accessor :shared_folder_uid
-      attr_accessor :shared_folder_gid
-      attr_accessor :system
-
-      # Represents a SubVM. This class is only used here in the VMs
-      # hash.
-      class SubVM
-        include Util::StackedProcRunner
-
-        def options
-          @options ||= {}
+    # Loads the queue of files/procs, executes them in the proper
+    # sequence, and returns the resulting configuration object.
+    def load!
+      self.class.reset!(@env)
+
+      queue.flatten.each do |item|
+        if item.is_a?(String) && File.exist?(item)
+          begin
+            load item
+          rescue SyntaxError => e
+            # Report syntax errors in a nice way for Vagrantfiles
+            raise Errors::VagrantfileSyntaxError.new(:file => e.message)
+          end
+        elsif item.is_a?(Proc)
+          self.class.run(&item)
         end
       end
 
-      def initialize
-        @forwarded_ports = {}
-        @shared_folders = {}
-        @provisioner = nil
-        @network_options = []
-      end
-
-      def forward_port(name, guestport, hostport, options=nil)
-        options = {
-          :guestport  => guestport,
-          :hostport   => hostport,
-          :protocol   => "TCP",
-          :adapter    => 0,
-          :auto       => false
-        }.merge(options || {})
-
-        forwarded_ports[name] = options
-      end
-
-      def share_folder(name, guestpath, hostpath, opts=nil)
-        @shared_folders[name] = {
-          :guestpath => guestpath,
-          :hostpath => hostpath
-        }.merge(opts || {})
-      end
-
-      def network(ip, options=nil)
-        options = {
-          :ip => ip,
-          :netmask => "255.255.255.0",
-          :adapter => 1,
-          :name => nil
-        }.merge(options || {})
-
-        @network_options[options[:adapter]] = options
-      end
-
-      def hd_location=(val)
-        raise Exception.new("disk_storage must be set to a directory") unless File.directory?(val)
-        @hd_location=val
-      end
-
-      def shared_folder_uid
-        @shared_folder_uid || env.config.ssh.username
-      end
-
-      def shared_folder_gid
-        @shared_folder_gid || env.config.ssh.username
-      end
-
-      def customize(&block)
-        push_proc(&block)
-      end
-
-      def has_multi_vms?
-        !defined_vms.empty?
-      end
-
-      def defined_vms
-        @defined_vms ||= {}
-      end
-
-      def define(name, options=nil, &block)
-        options ||= {}
-        defined_vms[name.to_sym] ||= SubVM.new
-        defined_vms[name.to_sym].options.merge!(options)
-        defined_vms[name.to_sym].push_proc(&block)
-      end
-    end
-
-    class PackageConfig < Base
-      attr_accessor :name
-    end
-
-    class VagrantConfig < Base
-      attr_accessor :dotfile_name
-      attr_accessor :log_output
-      attr_accessor :home
-      attr_accessor :host
-
-      def home
-        @home ? File.expand_path(@home) : nil
-      end
+      return self.class.execute!
     end
+  end
 
+  class Config
+    # This class is the "top" configure class, which handles registering
+    # other configuration classes as well as validation of all configured
+    # classes. This is the object which is returned by {Environment#config}
+    # and has accessors to all other configuration classes.
+    #
+    # If you're looking to create your own configuration class, see {Base}.
     class Top < Base
       @@configures = []
 
       class << self
+        # The list of registered configuration classes as well as the key
+        # they're registered under.
         def configures_list
           @@configures ||= []
         end
 
+        # Registers a configuration class with the given key. This method shouldn't
+        # be called. Instead, inherit from {Base} and call {Base.configures}.
         def configures(key, klass)
           configures_list << [key, klass]
           attr_reader key.to_sym
         end
       end
 
-      # Setup default configures
-      configures :package, PackageConfig
-      configures :nfs, NFSConfig
-      configures :ssh, SSHConfig
-      configures :unison, UnisonConfig
-      configures :vm, VMConfig
-      configures :vagrant, VagrantConfig
-
       def initialize(env=nil)
         self.class.configures_list.each do |key, klass|
           config = klass.new
@@ -234,23 +140,35 @@ module Vagrant
           instance_variable_set("@#{key}".to_sym, config)
         end
 
-        @loaded = false
         @env = env
       end
 
-      def loaded?
-        @loaded
-      end
-
-      def loaded!
-        @loaded = true
-      end
+      # Validates the configuration classes of this instance and raises an
+      # exception if they are invalid. If you are implementing a custom configuration
+      # class, the method you want to implement is {Base#validate}. This is
+      # the method that checks all the validation, not one which defines
+      # validation rules.
+      def validate!
+        # Validate each of the configured classes and store the results into
+        # a hash.
+        errors = self.class.configures_list.inject({}) do |container, data|
+          key, _ = data
+          recorder = ErrorRecorder.new
+          send(key.to_sym).validate(recorder)
+          container[key.to_sym] = recorder if !recorder.errors.empty?
+          container
+        end
 
-      # Deep clones the entire configuration tree using the marshalling
-      # trick. All subclasses must be able to marshal properly.
-      def deep_clone
-        Marshal.load(Marshal.dump(self))
+        return if errors.empty?
+        raise Errors::ConfigValidationFailed.new(:messages => Util::TemplateRenderer.render("config/validation_failed", :errors => errors))
       end
     end
   end
 end
+
+# The built-in configuration classes
+require 'vagrant/config/vagrant'
+require 'vagrant/config/ssh'
+require 'vagrant/config/nfs'
+require 'vagrant/config/vm'
+require 'vagrant/config/package'