`vagrant package` works with multi-VM environments

lib/vagrant/commands/package.rb

@@ -8,23 +8,58 @@ module Vagrant
       description "Packages a vagrant environment for distribution"
 
       def execute(args=[])
-        parse_options(args)
+        args = parse_options(args)
 
-        if !options[:base]
+        if options[:base]
-          # Packaging a pre-existing environment
+          package_base
-          env.require_persisted_vm
         else
+          package_single(args[0])
+        end
+      end
+
+      def package_base
         # Packaging a base box; that is a VM not tied to a specific
         # vagrant environment
         vm = VM.find(options[:base])
-          vm.env = env if vm
+        if !vm
-          env.vm = vm
+          error_and_exit(:vm_base_not_found, :name => options[:base])
-
+          return # for tests
-          error_and_exit(:vm_base_not_found, :name => options[:base]) unless vm
         end
 
-        error_and_exit(:vm_power_off_to_package) unless env.vm.powered_off?
+        vm.env = env
-        env.vm.package(args[0], options[:include])
+        package_vm(vm)
+      end
+
+      def package_single(name)
+        if name.nil? && env.multivm?
+          error_and_exit(:package_multivm)
+          return
+        end
+
+        vm = if name.nil?
+               env.vms.values.first
+             else
+               env.vms[name.to_sym]
+             end
+
+        if vm.nil?
+          error_and_exit(:unknown_vm, :vm => name)
+          return
+        elsif !vm.created?
+          error_and_exit(:environment_not_created)
+          return
+        end
+
+        package_vm(vm)
+      end
+
+      def package_vm(vm)
+        if !vm.powered_off?
+          error_and_exit(:vm_power_off_to_package)
+          return # for tests
+        end
+
+        vm.package(options[:output], options[:include])
       end
 
       def options_spec(opts)
@@ -32,14 +67,20 @@ module Vagrant
 
         # Defaults
         options[:include] = []
+        options[:base] = nil
+        options[:output] = nil
 
-        opts.on("--base [BASE]", "Name or UUID of VM to create a base box from") do |v|
+        opts.on("--base BASE", "Name or UUID of VM to create a base box from") do |v|
           options[:base] = v
         end
 
         opts.on("--include x,y,z", Array, "List of files to include in the package") do |v|
           options[:include] = v
         end
+
+        opts.on("-o", "--output FILE", "File to save the package as.") do |v|
+          options[:output] = v
+        end
       end
     end
   end

templates/strings.yml

@@ -108,6 +108,11 @@
   <%= Vagrant::Environment::ROOTFILE_NAME %> and running `vagrant up`
 :package_include_file_doesnt_exist: |-
   File specified to include: '<%= filename %>' does not exist!
+:package_multivm: |-
+  Because this Vagrant environment represents multiple VMs, a
+  specific VM must be specified. This can be done by calling
+  `vagrant package NAME` where NAME is a valid VM represented by
+  your Vagrantfile.
 :package_requires_export: |-
   Package must be used in conjunction with export.
 :provisioner_invalid_class: |-

test/vagrant/commands/package_test.rb

@@ -4,81 +4,102 @@ class CommandsPackageTest < Test::Unit::TestCase
   setup do
     @klass = Vagrant::Commands::Package
 
-    @persisted_vm = mock("persisted_vm")
-    @persisted_vm.stubs(:execute!)
-
     @env = mock_environment
-    @env.stubs(:require_persisted_vm)
-    @env.stubs(:vm).returns(@persisted_vm)
-
     @instance = @klass.new(@env)
   end
 
   context "executing" do
-    setup do
+    should "package base if a base is given" do
-      @persisted_vm.stubs(:package)
+      @instance.expects(:package_base).once
-      @persisted_vm.stubs(:powered_off?).returns(true)
+      @instance.execute(["--base","foo"])
     end
 
-    context "with no base specified" do
+    should "package single if no name is given" do
-      should "require a persisted vm" do
+      @instance.expects(:package_single).with(nil).once
-        @env.expects(:require_persisted_vm).once
       @instance.execute
     end
+
+    should "package single if a name is given" do
+      @instance.expects(:package_single).with("foo").once
+      @instance.execute(["foo"])
+    end
   end
 
-    context "with base specified" do
+  context "packaging base" do
+    should "error and exit if no VM is found" do
+      Vagrant::VM.expects(:find).with("foo").returns(nil)
+      @instance.expects(:error_and_exit).with(:vm_base_not_found, :name => "foo").once
+      @instance.execute(["--base", "foo"])
+    end
+
+    should "package the VM like any other VM" do
+      vm = mock("vm")
+      Vagrant::VM.expects(:find).with("foo").returns(vm)
+      vm.expects(:env=).with(@env).once
+      @instance.expects(:package_vm).with(vm).once
+      @instance.execute(["--base", "foo"])
+    end
+  end
+
+  context "packaging a single VM" do
     setup do
       @vm = mock("vm")
+      @vm.stubs(:created?).returns(true)
 
-        Vagrant::VM.stubs(:find).with(@name).returns(@vm)
+      @vms = {:bar => @vm}
-        @vm.stubs(:env=).with(@env)
+      @env.stubs(:vms).returns(@vms)
-        @env.stubs(:vm=)
+      @env.stubs(:multivm?).returns(false)
-
-        @name = "bar"
     end
 
-      should "find the given base and set it on the env" do
+    should "error and exit if no name is given in a multi-vm env" do
-        Vagrant::VM.expects(:find).with(@name).returns(@vm)
+      @env.stubs(:multivm?).returns(true)
-        @vm.expects(:env=).with(@env)
+      @instance.expects(:error_and_exit).with(:package_multivm).once
-        @env.expects(:vm=).with(@vm)
+      @instance.package_single(nil)
-
-        @instance.execute(["foo", "--base", @name])
     end
 
-      should "error if the VM is not found" do
+    should "error and exit if the VM doesn't exist" do
-        Vagrant::VM.expects(:find).with(@name).returns(nil)
+      @instance.expects(:error_and_exit).with(:unknown_vm, :vm => :foo).once
-        @instance.expects(:error_and_exit).with(:vm_base_not_found, :name => @name).once
+      @instance.package_single(:foo)
+    end
 
-        @instance.execute(["foo", "--base", @name])
+    should "error and exit if the VM is not created" do
+      @vm.stubs(:created?).returns(false)
+      @instance.expects(:error_and_exit).with(:environment_not_created).once
+      @instance.package_single(:bar)
+    end
+
+    should "use the first VM is no name is given in a single VM environment" do
+      @instance.expects(:package_vm).with(@vm).once
+      @instance.package_single(nil)
+    end
+
+    should "package the VM" do
+      @instance.expects(:package_vm).with(@vm).once
+      @instance.package_single(:bar)
     end
   end
 
-    context "shared (with and without base specified)" do
+  context "packaging a VM" do
-      should "error and exit if the VM is not powered off" do
+    setup do
-        @persisted_vm.stubs(:powered_off?).returns(false)
+      @vm = mock("vm")
+      @vm.stubs(:powered_off?).returns(true)
+
+      @options = {}
+      @instance.stubs(:options).returns(@options)
+    end
+
+    should "error and exit if VM is not powered off" do
+      @vm.stubs(:powered_off?).returns(false)
       @instance.expects(:error_and_exit).with(:vm_power_off_to_package).once
-        @persisted_vm.expects(:package).never
+      @instance.package_vm(@vm)
-        @instance.execute
     end
 
-      should "call package on the persisted VM" do
+    should "package the VM with the proper arguments" do
-        @persisted_vm.expects(:package).once
+      @options[:output] = "foo.box"
-        @instance.execute
+      @options[:include] = :bar
-      end
 
-      should "pass the out path and include_files to the package method" do
+      @vm.expects(:package).with(@options[:output], @options[:include]).once
-        out_path = mock("out_path")
+      @instance.package_vm(@vm)
-        include_files = "foo"
-        @persisted_vm.expects(:package).with(out_path, [include_files]).once
-        @instance.execute([out_path, "--include", include_files])
-      end
-
-      should "default to an empty array when not include_files are specified" do
-        out_path = mock("out_path")
-        @persisted_vm.expects(:package).with(out_path, []).once
-        @instance.execute([out_path])
-      end
     end
   end
 end