vagrant 0.1.0

data/lib/vagrant/actions/vm/export.rb

@@ -0,0 +1,41 @@
+module Vagrant
+  module Actions
+    module VM
+      class Export < Base
+        attr_reader :temp_dir
+
+        def execute!
+          setup_temp_dir
+          export
+        end
+
+        def cleanup
+          if temp_dir
+            logger.info "Removing temporary export directory..."
+            FileUtils.rm_r(temp_dir)
+          end
+        end
+
+        def rescue(exception)
+          cleanup
+        end
+
+        def setup_temp_dir
+          @temp_dir = File.join(Env.tmp_path, Time.now.to_i.to_s)
+
+          logger.info "Creating temporary directory for export..."
+          FileUtils.mkpath(temp_dir)
+        end
+
+        def ovf_path
+          File.join(temp_dir, Vagrant.config.vm.box_ovf)
+        end
+
+        def export
+          logger.info "Exporting VM to #{ovf_path} ..."
+          @runner.vm.export(ovf_path, {}, true)
+        end
+      end
+    end
+  end
+end

data/lib/vagrant/actions/vm/forward_ports.rb

@@ -0,0 +1,32 @@
+module Vagrant
+  module Actions
+    module VM
+      class ForwardPorts < Base
+        def execute!
+          clear
+          forward_ports
+        end
+
+        def clear
+          logger.info "Deleting any previously set forwarded ports..."
+          @runner.vm.forwarded_ports.collect { |p| p.destroy(true) }
+        end
+
+        def forward_ports
+          logger.info "Forwarding ports..."
+
+          Vagrant.config.vm.forwarded_ports.each do |name, options|
+            logger.info "Forwarding \"#{name}\": #{options[:guestport]} => #{options[:hostport]}"
+            port = VirtualBox::ForwardedPort.new
+            port.name = name
+            port.hostport = options[:hostport]
+            port.guestport = options[:guestport]
+            @runner.vm.forwarded_ports << port
+          end
+
+          @runner.vm.save(true)
+        end
+      end
+    end
+  end
+end

data/lib/vagrant/actions/vm/halt.rb

@@ -0,0 +1,14 @@
+module Vagrant
+  module Actions
+    module VM
+      class Halt < Base
+        def execute!
+          raise ActionException.new("VM is not running! Nothing to shut down!") unless @runner.vm.running?
+
+          logger.info "Forcing shutdown of VM..."
+          @runner.vm.stop(true)
+        end
+      end
+    end
+  end
+end

data/lib/vagrant/actions/vm/import.rb

@@ -0,0 +1,17 @@
+module Vagrant
+  module Actions
+    module VM
+      class Import < Base
+        def execute!
+          @runner.invoke_around_callback(:import) do
+            Busy.busy do
+              logger.info "Importing base VM (#{Vagrant::Env.box.ovf_file})..."
+              # Use the first argument passed to the action
+              @runner.vm = VirtualBox::VM.import(Vagrant::Env.box.ovf_file)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/vagrant/actions/vm/move_hard_drive.rb

@@ -0,0 +1,53 @@
+module Vagrant
+  module Actions
+    module VM
+      class MoveHardDrive < Base
+        def execute!
+          unless @runner.powered_off?
+            error_and_exit(<<-error)
+The virtual machine must be powered off to move its disk.
+error
+            return
+          end
+
+          destroy_drive_after { clone_and_attach }
+        end
+
+        def hard_drive
+          @hard_drive ||= find_hard_drive
+        end
+
+        # TODO won't work if the first disk is not the boot disk or even if there are multiple disks
+        def find_hard_drive
+          @runner.vm.storage_controllers.each do |sc|
+            sc.devices.each do |d|
+              return d if d.image.is_a?(VirtualBox::HardDrive)
+            end
+          end
+        end
+
+        def clone_and_attach
+          logger.info "Cloning current VM Disk to new location (#{new_image_path})..."
+          hard_drive.image = hard_drive.image.clone(new_image_path, Vagrant.config.vm.disk_image_format, true)
+
+          logger.info "Attaching new disk to VM ..."
+          @runner.vm.save
+        end
+
+        def destroy_drive_after
+          old_image = hard_drive.image
+
+          yield
+
+          logger.info "Destroying old VM Disk (#{old_image.filename})..."
+          old_image.destroy(true)
+        end
+
+        # Returns the path to the new location for the hard drive
+        def new_image_path
+          File.join(Vagrant.config.vm.hd_location, hard_drive.image.filename)
+        end
+      end
+    end
+  end
+end

data/lib/vagrant/actions/vm/package.rb

@@ -0,0 +1,61 @@
+module Vagrant
+  module Actions
+    module VM
+      class Package < Base
+        attr_accessor :out_path
+        attr_accessor :include_files
+        attr_reader :export_action
+
+        def initialize(vm, out_path = nil, include_files = nil, *args)
+          super
+          @out_path = out_path || "package"
+          @include_files = include_files || []
+          @temp_path = nil
+        end
+
+        def prepare
+          # Verify the existance of all the additional files, if any
+          @include_files.each do |file|
+            raise ActionException.new("#{file} does not exist") unless File.exists?(file)
+          end
+
+          # Get the export action and store a reference to it
+          @export_action = @runner.find_action(Export)
+          raise ActionException.new("Package must be used in conjunction with export.") unless @export_action
+        end
+
+        def execute!
+          compress
+        end
+
+        def tar_path
+          File.join(FileUtils.pwd, "#{out_path}#{Vagrant.config.package.extension}")
+        end
+
+        def temp_path
+          export_action.temp_dir
+        end
+
+        def compress
+          logger.info "Packaging VM into #{tar_path} ..."
+          Tar.open(tar_path, File::CREAT | File::WRONLY, 0644, Tar::GNU) do |tar|
+            begin
+              current_dir = FileUtils.pwd
+              @include_files.each do |f|
+                logger.info "Packaging additional file: #{f}"
+                tar.append_file(f)
+              end
+
+              FileUtils.cd(temp_path)
+
+              # Append tree will append the entire directory tree unless a relative folder reference is used
+              tar.append_tree(".")
+            ensure
+              FileUtils.cd(current_dir)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/vagrant/actions/vm/provision.rb

@@ -0,0 +1,71 @@
+module Vagrant
+  module Actions
+    module VM
+      class Provision < Base
+        def execute!
+          chown_provisioning_folder
+          setup_json
+          setup_solo_config
+          run_chef_solo
+        end
+
+        def chown_provisioning_folder
+          logger.info "Setting permissions on provisioning folder..."
+          SSH.execute do |ssh|
+            ssh.exec!("sudo chown #{Vagrant.config.ssh.username} #{Vagrant.config.chef.provisioning_path}")
+          end
+        end
+
+        def setup_json
+          logger.info "Generating JSON and uploading..."
+
+          # Set up initial configuration
+          data = {
+            :config => Vagrant.config,
+            :directory => Vagrant.config.vm.project_directory,
+          }
+
+          # And wrap it under the "vagrant" namespace
+          data = { :vagrant => data }
+
+          # Merge with the "extra data" which isn't put under the
+          # vagrant namespace by default
+          data.merge!(Vagrant.config.chef.json)
+
+          json = data.to_json
+
+          SSH.upload!(StringIO.new(json), File.join(Vagrant.config.chef.provisioning_path, "dna.json"))
+        end
+
+        def setup_solo_config
+          solo_file = <<-solo
+file_cache_path "#{Vagrant.config.chef.provisioning_path}"
+cookbook_path "#{cookbooks_path}"
+solo
+
+          logger.info "Uploading chef-solo configuration script..."
+          SSH.upload!(StringIO.new(solo_file), File.join(Vagrant.config.chef.provisioning_path, "solo.rb"))
+        end
+
+        def run_chef_solo
+          logger.info "Running chef recipes..."
+          SSH.execute do |ssh|
+            ssh.exec!("cd #{Vagrant.config.chef.provisioning_path} && sudo chef-solo -c solo.rb -j dna.json") do |channel, data, stream|
+              # TODO: Very verbose. It would be easier to save the data and only show it during
+              # an error, or when verbosity level is set high
+              logger.info("#{stream}: #{data}")
+            end
+          end
+        end
+
+        def cookbooks_path
+          File.join(Vagrant.config.chef.provisioning_path, "cookbooks")
+        end
+
+        def collect_shared_folders
+          ["vagrant-provisioning", File.expand_path(Vagrant.config.chef.cookbooks_path, Env.root_path), cookbooks_path]
+        end
+      end
+    end
+  end
+end

data/lib/vagrant/actions/vm/reload.rb

@@ -0,0 +1,17 @@
+module Vagrant
+  module Actions
+    module VM
+      class Reload < Base
+        def prepare
+          steps = [ForwardPorts, SharedFolders, Start]
+          steps.unshift(Halt) if @runner.vm.running?
+          steps << Provision if Vagrant.config.chef.enabled
+
+          steps.each do |action_klass|
+            @runner.add_action(action_klass)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/vagrant/actions/vm/resume.rb

@@ -0,0 +1,16 @@
+module Vagrant
+  module Actions
+    module VM
+      class Resume < Base
+        def execute!
+          if !@runner.vm.saved?
+            raise ActionException.new("The vagrant virtual environment you are trying to resume is not in a suspended state.")
+          end
+
+          logger.info "Resuming suspended VM..."
+          @runner.start
+        end
+      end
+    end
+  end
+end

data/lib/vagrant/actions/vm/shared_folders.rb

@@ -0,0 +1,69 @@
+module Vagrant
+  module Actions
+    module VM
+      class SharedFolders < Base
+        def shared_folders
+          shared_folders = @runner.invoke_callback(:collect_shared_folders)
+
+          # Basic filtering of shared folders. Basically only verifies that
+          # the result is an array of 3 elements. In the future this should
+          # also verify that the host path exists, the name is valid,
+          # and that the guest path is valid.
+          shared_folders.collect do |folder|
+            if folder.is_a?(Array) && folder.length == 3
+              folder
+            else
+              nil
+            end
+          end.compact
+        end
+
+        def before_boot
+          logger.info "Creating shared folders metadata..."
+
+          shared_folders.each do |name, hostpath, guestpath|
+            folder = VirtualBox::SharedFolder.new
+            folder.name = name
+            folder.hostpath = hostpath
+            @runner.vm.shared_folders << folder
+          end
+
+          @runner.vm.save(true)
+        end
+
+        def after_boot
+          logger.info "Mounting shared folders..."
+
+          Vagrant::SSH.execute do |ssh|
+            shared_folders.each do |name, hostpath, guestpath|
+              logger.info "-- #{name}: #{guestpath}"
+              ssh.exec!("sudo mkdir -p #{guestpath}")
+              mount_folder(ssh, name, guestpath)
+              ssh.exec!("sudo chown #{Vagrant.config.ssh.username} #{guestpath}")
+            end
+          end
+        end
+
+        def mount_folder(ssh, name, guestpath, sleeptime=5)
+          # Note: This method seems pretty OS-specific and could also use
+          # some configuration options. For now its duct tape and "works"
+          # but should be looked at in the future.
+          attempts = 0
+
+          while true
+            result = ssh.exec!("sudo mount -t vboxsf #{name} #{guestpath}") do |ch, type, data|
+              # net/ssh returns the value in ch[:result] (based on looking at source)
+              ch[:result] = !!(type == :stderr && data =~ /No such device/i)
+            end
+
+            break unless result
+
+            attempts += 1
+            raise ActionException.new("Failed to mount shared folders. vboxsf was not available.") if attempts >= 10
+            sleep sleeptime
+          end
+        end
+      end
+    end
+  end
+end

data/lib/vagrant/actions/vm/start.rb

@@ -0,0 +1,50 @@
+module Vagrant
+  module Actions
+    module VM
+      class Start < Base
+        def execute!
+          @runner.invoke_around_callback(:boot) do
+            # Startup the VM
+            boot
+
+            # Wait for it to complete booting, or error if we could
+            # never detect it booted up successfully
+            if !wait_for_boot
+              error_and_exit(<<-error)
+Failed to connect to VM! Failed to boot?
+error
+            end
+          end
+        end
+
+        def collect_shared_folders
+          # The root shared folder for the project
+          ["vagrant-root", Env.root_path, Vagrant.config.vm.project_directory]
+        end
+
+        def boot
+          logger.info "Booting VM..."
+          @runner.vm.start(:headless, true)
+        end
+
+        def wait_for_boot(sleeptime=5)
+          logger.info "Waiting for VM to boot..."
+
+          Vagrant.config[:ssh][:max_tries].to_i.times do |i|
+            logger.info "Trying to connect (attempt ##{i+1} of #{Vagrant.config[:ssh][:max_tries]})..."
+
+            if Vagrant::SSH.up?
+              logger.info "VM booted and ready for use!"
+              return true
+            end
+
+            sleep sleeptime
+          end
+
+          logger.info "Failed to connect to VM! Failed to boot?"
+          false
+        end
+      end
+    end
+  end
+end