nixme-vagrant 0.7.2

data/lib/vagrant/command/provision.rb

@@ -0,0 +1,17 @@
+module Vagrant
+  module Command
+    class ProvisionCommand < NamedBase
+      register "provision", "Rerun the provisioning scripts on a running VM"
+
+      def execute
+        target_vms.each do |vm|
+          if vm.created? && vm.vm.running?
+            vm.provision
+          else
+            vm.env.ui.info I18n.t("vagrant.commands.common.vm_not_created")
+          end
+        end
+      end
+    end
+  end
+end

data/lib/vagrant/command/reload.rb

@@ -0,0 +1,17 @@
+module Vagrant
+  module Command
+    class ReloadCommand < NamedBase
+      register "reload", "Reload the environment, halting it then restarting it."
+
+      def execute
+        target_vms.each do |vm|
+          if vm.created?
+            vm.reload
+          else
+            vm.env.ui.info I18n.t("vagrant.commands.common.vm_not_created")
+          end
+        end
+      end
+    end
+  end
+end

data/lib/vagrant/command/resume.rb

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

data/lib/vagrant/command/ssh.rb

@@ -0,0 +1,42 @@
+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 Errors::VMNotCreatedError if !ssh_vm.created?
+        raise Errors::VMNotRunningError if !ssh_vm.vm.running?
+        ssh_vm.ssh.connect
+      end
+
+      def ssh_vm
+        @ssh_vm ||= begin
+          vm = self.name.nil? && env.multivm? ? env.primary_vm : nil
+          raise Errors::MultiVMTargetRequired, :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,26 @@
+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 Errors::MultiVMTargetRequired, :command => "ssh_config" if target_vms.length > 1
+        vm = target_vms.first
+        raise Errors::VMNotCreatedError if !vm.created?
+
+        # We need to fix the file permissions of the key if they aren't set
+        # properly, otherwise if the user attempts to SSH in, it won't work!
+        vm.ssh.check_key_permissions(vm.env.config.ssh.private_key_path)
+
+        $stdout.puts(Util::TemplateRenderer.render("ssh_config", {
+          :host_key => options[:host] || "vagrant",
+          :ssh_host => vm.env.config.ssh.host,
+          :ssh_user => vm.env.config.ssh.username,
+          :ssh_port => vm.ssh.port,
+          :private_key_path => vm.env.config.ssh.private_key_path
+        }))
+      end
+    end
+  end
+end

data/lib/vagrant/command/status.rb

@@ -0,0 +1,22 @@
+module Vagrant
+  module Command
+    class StatusCommand < NamedBase
+      register "status", "Shows the status of the current Vagrant environment."
+
+      def route
+        state = nil
+        results = target_vms.collect do |vm|
+          state = vm.created? ? vm.vm.state.to_s : "not_created"
+          "#{vm.name.to_s.ljust(25)}#{state.gsub("_", " ")}"
+        end
+
+        state = target_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,19 @@
+module Vagrant
+  module Command
+    class UpCommand < NamedBase
+      class_option :provision, :type => :boolean, :default => true
+      register "up", "Creates the Vagrant environment"
+
+      def execute
+        target_vms.each do |vm|
+          if vm.created?
+            vm.env.ui.info I18n.t("vagrant.commands.up.vm_created")
+            vm.start("provision.enabled" => options[:provision])
+          else
+            vm.up("provision.enabled" => options[:provision])
+          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

@@ -0,0 +1,123 @@
+require 'vagrant/config/base'
+require 'vagrant/config/error_recorder'
+require 'vagrant/config/top'
+
+# 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'
+
+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
+  #     config.set(:first, "/path/to/some/Vagrantfile")
+  #     config.set(:second, "/path/to/another/Vagrantfile")
+  #     config.load_order = [:first, :second]
+  #     result = config.load(env)
+  #
+  #     p "Your box is: #{result.vm.box}"
+  #
+  # The load order determines what order the config files specified are loaded.
+  # If a key is not mentioned (for example if above the load order was set to
+  # `[:first]`, therefore `:second` was not mentioned), then that config file
+  # won't be loaded.
+  class Config
+    # An array of symbols specifying the load order for the procs.
+    attr_accessor :load_order
+    attr_reader :procs
+
+    # This is the method which is called by all Vagrantfiles to configure Vagrant.
+    # This method expects a block which accepts a single argument representing
+    # an instance of the {Config::Top} class.
+    #
+    # Note that the block is not run immediately. Instead, it's proc is stored
+    # away for execution later.
+    def self.run(&block)
+      # Store it for later
+      @last_procs ||= []
+      @last_procs << block
+    end
+
+    # Returns the last proc which was activated for the class via {run}. This
+    # also sets the last proc to `nil` so that calling this method multiple times
+    # will not return duplicates.
+    #
+    # @return [Proc]
+    def self.last_proc
+      value = @last_procs
+      @last_procs = nil
+      value
+    end
+
+    def initialize(parent=nil)
+      @procs = {}
+      @load_order = []
+
+      if parent
+        # Shallow copy the procs and load order from parent if given
+        @procs = parent.procs.dup
+        @load_order = parent.load_order.dup
+      end
+    end
+
+    # Adds a Vagrantfile to be loaded to the queue of config procs. Note
+    # that this causes the Vagrantfile file to be loaded at this point,
+    # and it will never be loaded again.
+    def set(key, path)
+      return if @procs.has_key?(key)
+      @procs[key] = [path].flatten.map(&method(:proc_for)).flatten
+    end
+
+    # Loads the added procs using the set `load_order` attribute and returns
+    # the {Config::Top} object result. The configuration is loaded for the
+    # given {Environment} object.
+    #
+    # @param [Environment] env
+    def load(env)
+      config = Top.new(env)
+
+      # Only run the procs specified in the load order, in the order
+      # specified.
+      load_order.each do |key|
+        if @procs[key]
+          @procs[key].each do |proc|
+            proc.call(config) if proc
+          end
+        end
+      end
+
+      config
+    end
+
+    protected
+
+    def proc_for(path)
+      return nil if !path
+      return path if path.is_a?(Proc)
+
+      begin
+        Kernel.load path if File.exist?(path)
+        return self.class.last_proc
+      rescue SyntaxError => e
+        # Report syntax errors in a nice way for Vagrantfiles
+        raise Errors::VagrantfileSyntaxError, :file => e.message
+      end
+    end
+  end
+end

data/lib/vagrant/config/base.rb

@@ -0,0 +1,85 @@
+module Vagrant
+  class 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
+      # to instance variables on the class.
+      def self.json_create(data)
+        data.inject(new) do |result, data|
+          key, value = data
+          result.instance_variable_set("@#{key}".to_sym, value) if key != "json_class"
+          result
+        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.
+      def set_options(options)
+        options.each do |key, value|
+          send("#{key}=", value)
+        end
+      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
+
+      # Converts the configuration to a raw hash by calling `#to_hash`
+      # on all instance variables (if it can) and putting them into
+      # a hash.
+      def to_hash
+        instance_variables_hash.inject({}) do |acc, data|
+          k,v = data
+          v = v.to_hash if v.respond_to?(:to_hash)
+          acc[k] = v
+          acc
+        end
+      end
+
+      # Converts to JSON, with the `json_class` field set so that when
+      # 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)
+      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
+        end
+      end
+    end
+  end
+end