vagrantup 0.8.10 → 0.9.0

data/lib/vagrant/command/box_remove.rb

@@ -0,0 +1,23 @@
+require 'optparse'
+
+module Vagrant
+  module Command
+    class BoxRemove < Base
+      def execute
+        options = {}
+
+        opts = OptionParser.new do |opts|
+          opts.banner = "Usage: vagrant box remove <name>"
+        end
+
+        # Parse the options
+        argv = parse_options(opts)
+        return if !argv
+
+        b = @env.boxes.find(argv[0])
+        raise Errors::BoxNotFound, :name => argv[0] if !b
+        b.destroy
+      end
+    end
+  end
+end

data/lib/vagrant/command/box_repackage.rb

@@ -0,0 +1,23 @@
+require 'optparse'
+
+module Vagrant
+  module Command
+    class BoxRepackage < Base
+      def execute
+        options = {}
+
+        opts = OptionParser.new do |opts|
+          opts.banner = "Usage: vagrant box repackage <name>"
+        end
+
+        # Parse the options
+        argv = parse_options(opts)
+        return if !argv
+
+        b = @env.boxes.find(argv[0])
+        raise Errors::BoxNotFound, :name => argv[0] if !b
+        b.repackage
+      end
+    end
+  end
+end

data/lib/vagrant/command/destroy.rb

@@ -1,14 +1,25 @@
+require 'optparse'
+
 module Vagrant
   module Command
-    class DestroyCommand < NamedBase
-      register "destroy", "Destroy the environment, deleting the created virtual machines"
-
+    class Destroy < Base
       def execute
-        target_vms.each do |vm|
+        opts = OptionParser.new do |opts|
+          opts.banner = "Usage: vagrant destroy [vm-name]"
+        end
+
+        # Parse the options
+        argv = parse_options(opts)
+        return if !argv
+
+        @logger.debug("'Destroy' each target VM...")
+        with_target_vms(argv[0]) do |vm|
           if vm.created?
+            @logger.info("Destroying: #{vm.name}")
             vm.destroy
           else
-            vm.env.ui.info I18n.t("vagrant.commands.common.vm_not_created")
+            @logger.info("Not destroying #{vm.name}, since it isn't created.")
+            vm.ui.info I18n.t("vagrant.commands.common.vm_not_created")
           end
         end
       end

data/lib/vagrant/command/halt.rb

@@ -1,15 +1,33 @@
+require 'optparse'
+
 module Vagrant
   module Command
-    class HaltCommand < NamedBase
-      class_option :force, :type => :boolean, :default => false, :aliases => "-f"
-      register "halt", "Halt the running VMs in the environment"
-
+    class Halt < Base
       def execute
-        target_vms.each do |vm|
+        options = {}
+
+        opts = OptionParser.new do |opts|
+          opts.banner = "Usage: vagrant halt [vm-name] [--force] [-h]"
+
+          opts.separator ""
+
+          opts.on("-f", "--force", "Force shut down (equivalent of pulling power)") do |f|
+            options[:force] = f
+          end
+        end
+
+        # Parse the options
+        argv = parse_options(opts)
+        return if !argv
+
+        @logger.debug("Halt command: #{argv.inspect} #{options.inspect}")
+        with_target_vms(argv[0]) do |vm|
           if vm.created?
-            vm.halt(options)
+            @logger.info("Halting #{vm.name}")
+            vm.halt(:force => options[:force])
           else
-            vm.env.ui.info I18n.t("vagrant.commands.common.vm_not_created")
+            @logger.info("Not halting #{vm.name}, since not created.")
+            vm.ui.info I18n.t("vagrant.commands.common.vm_not_created")
           end
         end
       end

data/lib/vagrant/command/init.rb

@@ -1,13 +1,36 @@
+require 'optparse'
+
+require 'vagrant/util/template_renderer'
+
 module Vagrant
   module Command
-    class InitCommand < Base
-      argument :box_name, :type => :string, :optional => true, :default => "base"
-      argument :box_url, :type => :string, :optional => true
-      source_root File.expand_path("templates/commands/init", Vagrant.source_root)
-      register "init [box_name] [box_url]", "Initializes the current folder for Vagrant usage"
-
+    class Init < Base
       def execute
-        template "Vagrantfile.erb", env.cwd.join("Vagrantfile")
+        options = {}
+
+        opts = OptionParser.new do |opts|
+          opts.banner = "Usage: vagrant init [box-name] [box-url]"
+        end
+
+        # Parse the options
+        argv = parse_options(opts)
+        return if !argv
+
+        save_path = @env.cwd.join("Vagrantfile")
+        raise Errors::VagrantfileExistsError if save_path.exist?
+
+        template_path = ::Vagrant.source_root.join("templates/commands/init/Vagrantfile")
+        contents = Vagrant::Util::TemplateRenderer.render(template_path,
+                                                          :box_name => argv[0] || "base",
+                                                          :box_url => argv[1])
+
+        # Write out the contents
+        save_path.open("w+") do |f|
+          f.write(contents)
+        end
+
+        @env.ui.info(I18n.t("vagrant.commands.init.success"),
+                     :prefix => false)
       end
     end
   end

data/lib/vagrant/command/package.rb

@@ -1,33 +1,64 @@
+require 'optparse'
+
 module Vagrant
   module Command
-    class PackageCommand < NamedBase
-      class_option :base, :type => :string, :default => nil
-      class_option :output, :type => :string, :default => nil
-      class_option :include, :type => :array, :default => nil
-      class_option :vagrantfile, :type => :string, :default => nil
-      register "package", "Package a Vagrant environment for distribution"
-
+    class Package < Base
       def execute
-        return package_base if options[:base]
-        package_target
+        options = {}
+
+        opts = OptionParser.new do |opts|
+          opts.banner = "Usage: vagrant package [vm-name] [--base name] [--output name.box]"
+          opts.separator "                       [--include one,two,three] [--vagrantfile file]"
+
+          opts.separator ""
+
+          opts.on("--base NAME", "Name of a VM in virtualbox to package as a base box") do |b|
+            options[:base] = b
+          end
+
+          opts.on("--output NAME", "Name of the file to output") do |o|
+            options[:output] = o
+          end
+
+          opts.on("--include x,y,z", Array, "Additional files to package with the box.") do |i|
+            options[:include] = i
+          end
+
+          opts.on("--vagrantfile file", "Vagrantfile to package with the box.") do |v|
+            options[:vagrantfile] = v
+          end
+        end
+
+        # Parse the options
+        argv = parse_options(opts)
+        return if !argv
+
+        @logger.debug("package options: #{options.inspect}")
+        if options[:base]
+          package_base(options)
+        else
+          package_target(argv[0], options)
+        end
       end
 
       protected
 
-      def package_base
-        vm = VM.find(options[:base], env)
+      def package_base(options)
+        vm = VM.new(options[:base], @env, @env.config.global, :base => true)
         raise Errors::BaseVMNotFound, :name => options[:base] if !vm.created?
-        package_vm(vm)
+        @logger.debug("Packaging base VM: #{vm.name}")
+        package_vm(vm, options)
       end
 
-      def package_target
-        raise Errors::MultiVMTargetRequired, :command => "package" if target_vms.length > 1
-        vm = target_vms.first
-        raise Errors::VMNotCreatedError if !vm.created?
-        package_vm(vm)
+      def package_target(name, options)
+        with_target_vms(name, true) do |vm|
+          raise Errors::VMNotCreatedError if !vm.created?
+          @logger.debug("Packaging VM: #{vm.name}")
+          package_vm(vm, options)
+        end
       end
 
-      def package_vm(vm)
+      def package_vm(vm, options)
         opts = options.inject({}) do |acc, data|
           k,v = data
           acc["package.#{k}"] = v

data/lib/vagrant/command/provision.rb

@@ -1,20 +1,33 @@
+require 'optparse'
+
 module Vagrant
   module Command
-    class ProvisionCommand < NamedBase
-      register "provision", "Rerun the provisioning scripts on a running VM"
-
+    class Provision < Base
       def execute
-        target_vms.each do |vm|
+        options = {}
+
+        opts = OptionParser.new do |opts|
+          opts.banner = "Usage: vagrant provision [vm-name]"
+        end
+
+        # Parse the options
+        argv = parse_options(opts)
+        return if !argv
+
+        # Go over each VM and provision!
+        @logger.debug("'provision' each target VM...")
+        with_target_vms(argv[0]) do |vm|
           if vm.created?
-            if !vm.vm.accessible?
-              raise Errors::VMInaccessible
-            elsif vm.vm.running?
+            if vm.state == :running
+              @logger.info("Provisioning: #{vm.name}")
               vm.provision
             else
-              vm.env.ui.info I18n.t("vagrant.commands.common.vm_not_running")
+              @logger.info("#{vm.name} not running. Not provisioning.")
+              vm.ui.info I18n.t("vagrant.commands.common.vm_not_running")
             end
           else
-            vm.env.ui.info I18n.t("vagrant.commands.common.vm_not_created")
+            @logger.info("#{vm.name} not created. Not provisioning.")
+            vm.ui.info I18n.t("vagrant.commands.common.vm_not_created")
           end
         end
       end

data/lib/vagrant/command/reload.rb

@@ -1,14 +1,27 @@
+require 'optparse'
+
 module Vagrant
   module Command
-    class ReloadCommand < NamedBase
-      register "reload", "Reload the environment, halting it then restarting it."
-
+    class Reload < Base
       def execute
-        target_vms.each do |vm|
+        options = {}
+
+        opts = OptionParser.new do |opts|
+          opts.banner = "Usage: vagrant reload [vm-name]"
+        end
+
+        # Parse the options
+        argv = parse_options(opts)
+        return if !argv
+
+        @logger.debug("'reload' each target VM...")
+        with_target_vms(argv[0]) do |vm|
           if vm.created?
+            @logger.info("Reloading: #{vm.name}")
             vm.reload
           else
-            vm.env.ui.info I18n.t("vagrant.commands.common.vm_not_created")
+            @logger.info("Not created: #{vm.name}. Not reloading.")
+            vm.ui.info I18n.t("vagrant.commands.common.vm_not_created")
           end
         end
       end

data/lib/vagrant/command/resume.rb

@@ -1,14 +1,27 @@
+require 'optparse'
+
 module Vagrant
   module Command
-    class ResumeCommand < NamedBase
-      register "resume", "Resume a suspended Vagrant environment."
-
+    class Resume < Base
       def execute
-        target_vms.each do |vm|
+        options = {}
+
+        opts = OptionParser.new do |opts|
+          opts.banner = "Usage: vagrant resume [vm-name]"
+        end
+
+        # Parse the options
+        argv = parse_options(opts)
+        return if !argv
+
+        @logger.debug("'resume' each target VM...")
+        with_target_vms(argv[0]) do |vm|
           if vm.created?
+            @logger.info("Resume: #{vm.name}")
             vm.resume
           else
-            vm.env.ui.info I18n.t("vagrant.commands.common.vm_not_created")
+            @logger.info("Not created: #{vm.name}. Not resuming.")
+            vm.ui.info I18n.t("vagrant.commands.common.vm_not_created")
           end
         end
       end

data/lib/vagrant/command/ssh.rb

@@ -1,49 +1,87 @@
+require 'optparse'
+
 module Vagrant
   module Command
-    class SSHCommand < NamedBase
-      class_option :command, :type => :string, :default => false, :aliases => "-c"
-      register "ssh", "SSH into the currently running Vagrant environment."
-
+    class SSH < Base
       def execute
-        if options[:command]
-          ssh_execute
-        else
-          ssh_connect
-        end
-      end
+        options = {}
 
-      protected
+        opts = OptionParser.new do |opts|
+          opts.banner = "Usage: vagrant ssh [vm-name] [-c command] [-- extra ssh args]"
+
+          opts.separator ""
 
-      def ssh_execute
-        ssh_vm.ssh.execute do |ssh|
-          ssh.exec!(options[:command]) do |channel, type, data|
-            if type != :exit_status
-              # Print the SSH output as it comes in, but don't prefix it and don't
-              # force a new line so that the output is properly preserved
-              ssh_vm.env.ui.info(data.to_s, :prefix => false, :new_line => false)
-            end
+          opts.on("-c", "--command COMMAND", "Execute an SSH command directly.") do |c|
+            options[:command] = c
+          end
+          opts.on("-p", "--plain", "Plain mode, leaves authentication up to user.") do |p|
+            options[:plain_mode] = p
           end
         end
-      end
 
-      def ssh_connect
-        ssh_vm.ssh.connect
-      end
+        # Parse the options and return if we don't have any target.
+        argv = parse_options(opts)
+        return if !argv
 
-      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
+        # Parse out the extra args to send to SSH, which is everything
+        # after the "--"
+        ssh_args = ARGV.drop_while { |i| i != "--" }
+        ssh_args = ssh_args[1..-1]
+        options[:ssh_args] = ssh_args
 
+        # If the remaining arguments ARE the SSH arguments, then just
+        # clear it out. This happens because optparse returns what is
+        # after the "--" as remaining ARGV, and Vagrant can think it is
+        # a multi-vm name (wrong!)
+        argv = [] if argv == ssh_args
+
+        # Execute the actual SSH
+        with_target_vms(argv[0], true) do |vm|
           # Basic checks that are required for proper SSH
           raise Errors::VMNotCreatedError if !vm.created?
-          raise Errors::VMInaccessible if !vm.vm.accessible?
-          raise Errors::VMNotRunningError if !vm.vm.running?
+          raise Errors::VMInaccessible if !vm.state == :inaccessible
+          raise Errors::VMNotRunningError if vm.state != :running
+
+          if options[:command]
+            ssh_execute(vm, options[:command])
+          else
+            opts = {
+              :plain_mode => options[:plain_mode],
+              :extra_args => options[:ssh_args]
+            }
 
-          vm
+            ssh_connect(vm, opts)
+          end
         end
       end
+
+      protected
+
+      def ssh_execute(vm, command=nil)
+        exit_status = 0
+
+        @logger.debug("Executing command: #{command}")
+        exit_status = vm.channel.execute(command, :error_check => false) do |type, data|
+          # Determine the proper channel to send the output onto depending
+          # on the type of data we are receiving.
+          channel = type == :stdout ? :out : :error
+
+          # Print the SSH output as it comes in, but don't prefix it and don't
+          # force a new line so that the output is properly preserved
+          vm.ui.info(data.to_s,
+                     :prefix => false,
+                     :new_line => false,
+                     :channel => channel)
+        end
+
+        # Exit with the exit status we got from executing the command
+        exit exit_status
+      end
+
+      def ssh_connect(vm, opts)
+        @logger.debug("`exec` into ssh prompt")
+        vm.ssh.exec(opts)
+      end
     end
   end
 end

data/lib/vagrant/command/ssh_config.rb

@@ -1,28 +1,43 @@
+require 'optparse'
+
 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"
-
+    class SSHConfig < Base
       def execute
-        raise Errors::MultiVMTargetRequired, :command => "ssh_config" if target_vms.length > 1
-        vm = target_vms.first
-        raise Errors::VMNotCreatedError if !vm.created?
-        raise Errors::VMInaccessible if !vm.vm.accessible?
-
-        # 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] || vm.name || "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,
-          :forward_agent => vm.env.config.ssh.forward_agent,
-          :forward_x11   => vm.env.config.ssh.forward_x11
-        }))
+        options = {}
+
+        opts = OptionParser.new do |opts|
+          opts.banner = "Usage: vagrant ssh-config [vm-name] [-h name]"
+
+          opts.separator ""
+
+          opts.on("-h", "--host COMMAND", "Name the host for the config..") do |h|
+            options[:host] = h
+          end
+        end
+
+        argv = parse_options(opts)
+        return if !argv
+
+        with_target_vms(argv[0], true) do |vm|
+          raise Errors::VMNotCreatedError if !vm.created?
+          raise Errors::VMInaccessible if !vm.state == :inaccessible
+
+          ssh_info  = vm.ssh.info
+          variables = {
+            :host_key => options[:host] || vm.name || "vagrant",
+            :ssh_host => ssh_info[:host],
+            :ssh_port => ssh_info[:port],
+            :ssh_user => ssh_info[:username],
+            :private_key_path => ssh_info[:private_key_path],
+            :forward_agent => ssh_info[:forward_agent],
+            :forward_x11   => ssh_info[:forward_x11]
+          }
+
+          # Render the template and output directly to STDOUT
+          template = "commands/ssh_config/config"
+          $stdout.puts(Util::TemplateRenderer.render(template, variables))
+        end
       end
     end
   end

data/lib/vagrant/command/status.rb

@@ -1,30 +1,32 @@
+require 'optparse'
+
 module Vagrant
   module Command
-    class StatusCommand < NamedBase
-      register "status", "Shows the status of the current Vagrant environment."
-
+    class Status < Base
       def execute
-        state = nil
-        results = target_vms.collect do |vm|
-          if vm.created?
-            if vm.vm.accessible?
-              state = vm.vm.state.to_s
-            else
-              state = "inaccessible"
-            end
-          else
-            state = "not_created"
-          end
+        options = {}
 
-          "#{vm.name.to_s.ljust(25)}#{state.gsub("_", " ")}"
+        opts = OptionParser.new do |opts|
+          opts.banner = "Usage: vagrant status [vm-name]"
+        end
+
+        # Parse the options
+        argv = parse_options(opts)
+        return if !argv
+
+        state = nil
+        results = []
+        with_target_vms(argv[0]) do |vm|
+          state = vm.state.to_s if !state
+          results << "#{vm.name.to_s.ljust(25)}#{vm.state.to_s.gsub("_", " ")}"
         end
 
-        state = target_vms.length == 1 ? state : "listing"
+        state = results.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)
+        @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

data/lib/vagrant/command/suspend.rb

@@ -1,14 +1,27 @@
+require 'optparse'
+
 module Vagrant
   module Command
-    class SuspendCommand < NamedBase
-      register "suspend", "Suspend a running Vagrant environment."
-
+    class Suspend < Base
       def execute
-        target_vms.each do |vm|
+        options = {}
+
+        opts = OptionParser.new do |opts|
+          opts.banner = "Usage: vagrant suspend [vm-name]"
+        end
+
+        # Parse the options
+        argv = parse_options(opts)
+        return if !argv
+
+        @logger.debug("'suspend' each target VM...")
+        with_target_vms(argv[0]) do |vm|
           if vm.created?
+            @logger.info("Suspending: #{vm.name}")
             vm.suspend
           else
-            vm.env.ui.info I18n.t("vagrant.commands.common.vm_not_created")
+            @logger.info("Not created: #{vm.name}. Not suspending.")
+            vm.ui.info I18n.t("vagrant.commands.common.vm_not_created")
           end
         end
       end