bmabey-vagrant 0.2.0

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

@@ -0,0 +1,47 @@
+module Vagrant
+  module Actions
+    module VM
+      class Boot < Base
+        def prepare
+          @runner.env.config.vm.share_folder("vagrant-root", @runner.env.config.vm.project_directory, @runner.env.root_path)
+        end
+
+        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(:vm_failed_to_boot)
+            end
+          end
+        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..."
+
+          @runner.env.config.ssh.max_tries.to_i.times do |i|
+            logger.info "Trying to connect (attempt ##{i+1} of #{Vagrant.config[:ssh][:max_tries]})..."
+
+            if @runner.env.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

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

@@ -0,0 +1,17 @@
+module Vagrant
+  module Actions
+    module VM
+      class Customize < Base
+        def execute!
+          logger.info "Running any VM customizations..."
+
+          # Run the customization procs over the VM
+          @runner.env.config.vm.run_procs!(@runner.vm)
+
+          # Save the vm
+          @runner.vm.save(true)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,23 @@
+module Vagrant
+  module Actions
+    module VM
+      class Destroy < Base
+        def execute!
+          @runner.invoke_around_callback(:destroy) do
+            destroy_vm
+            depersist
+          end
+        end
+
+        def destroy_vm
+          logger.info "Destroying VM and associated drives..."
+          @runner.vm.destroy(:destroy_image => true)
+        end
+
+        def depersist
+          @runner.env.depersist_vm
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,12 @@
+module Vagrant
+  module Actions
+    module VM
+      class Down < Base
+        def prepare
+          @runner.add_action(Halt) if @runner.vm.running?
+          @runner.add_action(Destroy)
+        end
+      end
+    end
+  end
+end

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(@runner.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, @runner.env.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,46 @@
+module Vagrant
+  module Actions
+    module VM
+      class ForwardPorts < Base
+        def prepare
+          VirtualBox::VM.all.each do |vm|
+            next if !vm.running? || vm.uuid == @runner.uuid
+
+            vm.forwarded_ports.each do |fp|
+              @runner.env.config.vm.forwarded_ports.each do |name, options|
+                if fp.hostport.to_s == options[:hostport].to_s
+                  raise ActionException.new(:vm_port_collision, :name => name, :hostport => fp.hostport.to_s, :guestport => options[:guestport].to_s)
+                end
+              end
+            end
+          end
+        end
+
+        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..."
+
+          @runner.env.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_not_running) 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,18 @@
+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 (#{@runner.env.box.ovf_file})..."
+              # Use the first argument passed to the action
+              @runner.vm = VirtualBox::VM.import(@runner.env.box.ovf_file)
+              raise ActionException.new(:virtualbox_import_failure) unless @runner.vm
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,51 @@
+module Vagrant
+  module Actions
+    module VM
+      class MoveHardDrive < Base
+        def execute!
+          unless @runner.powered_off?
+            error_and_exit(:vm_power_off_to_move_hd)
+            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,65 @@
+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(:package_include_file_doesnt_exist, :filename => file) unless File.exists?(file)
+          end
+
+          # Get the export action and store a reference to it
+          @export_action = @runner.find_action(Export)
+          raise ActionException.new(:packaged_requires_export) unless @export_action
+        end
+
+        def execute!
+          compress
+        end
+
+        def tar_path
+          File.join(FileUtils.pwd, "#{out_path}#{@runner.env.config.package.extension}")
+        end
+
+        def temp_path
+          export_action.temp_dir
+        end
+
+        def compress
+          logger.info "Packaging VM into #{tar_path} ..."
+          File.open(tar_path, File::CREAT | File::WRONLY, 0644) do |tar|
+            Archive::Tar::Minitar::Output.open(tar) do |output|
+              begin
+                current_dir = FileUtils.pwd
+
+                include_files.each do |f|
+                  logger.info "Packaging additional file: #{f}"
+                  Archive::Tar::Minitar.pack_file(f, output)
+                end
+
+                FileUtils.cd(temp_path)
+
+                Dir.glob(File.join(".", "*")).each do |entry|
+                  Archive::Tar::Minitar.pack_file(entry, output)
+                end
+              ensure
+                FileUtils.cd(current_dir)
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,49 @@
+module Vagrant
+  module Actions
+    module VM
+      class Provision < Base
+        attr_reader :provisioner
+
+        def intialize(*args)
+          super
+
+          @provisioner = nil
+        end
+
+        def prepare
+          provisioner = Vagrant.config.vm.provisioner
+
+          if provisioner.nil?
+            logger.info("Provisioning not enabled, ignoring this step")
+            return
+          end
+
+          if provisioner.is_a?(Class)
+            @provisioner = provisioner.new(@runner.env)
+            raise ActionException.new(:provisioner_invalid_class) unless @provisioner.is_a?(Provisioners::Base)
+          elsif provisioner.is_a?(Symbol)
+            # We have a few hard coded provisioners for built-ins
+            mapping = {
+              :chef_solo    => Provisioners::ChefSolo,
+              :chef_server  => Provisioners::ChefServer
+            }
+
+            provisioner_klass = mapping[provisioner]
+            raise ActionException.new(:provisioner_unknown_type, :provisioner => provisioner.to_s) if provisioner_klass.nil?
+            @provisioner = provisioner_klass.new(@runner.env)
+          end
+
+          logger.info "Provisioning enabled with #{@provisioner.class}"
+          @provisioner.prepare
+        end
+
+        def execute!
+          if provisioner
+            logger.info "Beginning provisioning process..."
+            provisioner.provision!
+          end
+        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 = [Customize, ForwardPorts, SharedFolders, Boot]
+          steps.unshift(Halt) if @runner.vm.running?
+          steps << Provision if !@runner.env.config.vm.provisioner.nil?
+
+          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(:vm_not_suspended)
+          end
+
+          logger.info "Resuming suspended VM..."
+          @runner.start
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,81 @@
+module Vagrant
+  module Actions
+    module VM
+      class SharedFolders < Base
+        def shared_folders
+          @runner.env.config.vm.shared_folders.inject([]) do |acc, data|
+            name, value = data
+            acc << [name, File.expand_path(value[:hostpath]), value[:guestpath]]
+          end
+        end
+
+        def before_boot
+          clear_shared_folders
+          create_metadata
+        end
+
+        def after_boot
+          logger.info "Mounting shared folders..."
+
+          @runner.env.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 clear_shared_folders
+          logger.info "Clearing previously set shared folders..."
+
+          @runner.vm.shared_folders.each do |shared_folder|
+            shared_folder.destroy
+          end
+
+          @runner.reload!
+        end
+
+        def create_metadata
+          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 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.
+
+          # Determine the permission string to attach to the mount command
+          perms = []
+          perms << "uid=#{@runner.env.config.vm.shared_folder_uid}"
+          perms << "gid=#{@runner.env.config.vm.shared_folder_gid}"
+          perms = " -o #{perms.join(",")}" if !perms.empty?
+
+          attempts = 0
+          while true
+            result = ssh.exec!("sudo mount -t vboxsf#{perms} #{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(:vm_mount_fail) if attempts >= 10
+            sleep sleeptime
+          end
+        end
+      end
+    end
+  end
+end