tnargav 1.3.5 → 1.3.6

data/plugins/providers/virtualbox/action/boot.rb

@@ -0,0 +1,23 @@
+module VagrantPlugins
+  module ProviderVirtualBox
+    module Action
+      class Boot
+        def initialize(app, env)
+          @app = app
+        end
+
+        def call(env)
+          @env = env
+
+          boot_mode = @env[:machine].provider_config.gui ? "gui" : "headless"
+
+          # Start up the VM and wait for it to boot.
+          env[:ui].info I18n.t("vagrant.actions.vm.boot.booting")
+          env[:machine].provider.driver.start(boot_mode)
+
+          @app.call(env)
+        end
+      end
+    end
+  end
+end

data/plugins/providers/virtualbox/action/check_accessible.rb

@@ -0,0 +1,23 @@
+module VagrantPlugins
+  module ProviderVirtualBox
+    module Action
+      class CheckAccessible
+        def initialize(app, env)
+          @app = app
+        end
+
+        def call(env)
+          if env[:machine].state.id == :inaccessible
+            # The VM we are attempting to manipulate is inaccessible. This
+            # is a very bad situation and can only be fixed by the user. It
+            # also prohibits us from actually doing anything with the virtual
+            # machine, so we raise an error.
+            raise Vagrant::Errors::VMInaccessible
+          end
+
+          @app.call(env)
+        end
+      end
+    end
+  end
+end

data/plugins/providers/virtualbox/action/check_created.rb

@@ -0,0 +1,21 @@
+module VagrantPlugins
+  module ProviderVirtualBox
+    module Action
+      # This middleware checks that the VM is created, and raises an exception
+      # if it is not, notifying the user that creation is required.
+      class CheckCreated
+        def initialize(app, env)
+          @app = app
+        end
+
+        def call(env)
+          if env[:machine].state.id == :not_created
+            raise Vagrant::Errors::VMNotCreatedError
+          end
+
+          @app.call(env)
+        end
+      end
+    end
+  end
+end

data/plugins/providers/virtualbox/action/check_guest_additions.rb

@@ -0,0 +1,45 @@
+module VagrantPlugins
+  module ProviderVirtualBox
+    module Action
+      class CheckGuestAdditions
+        def initialize(app, env)
+          @app = app
+        end
+
+        def call(env)
+          # Use the raw interface for now, while the virtualbox gem
+          # doesn't support guest properties (due to cross platform issues)
+          version = env[:machine].provider.driver.read_guest_additions_version
+          if !version
+            env[:ui].warn I18n.t("vagrant.actions.vm.check_guest_additions.not_detected")
+          else
+            # Read the versions
+            versions = [version, env[:machine].provider.driver.version]
+
+            # Strip of any -OSE or _OSE and read only the first two parts
+            # of the version such as "4.2" in "4.2.0"
+            versions.map! do |v|
+              v     = v.gsub(/[-_]ose/i, '')
+              match = /^(\d+\.\d+)\.(\d+)/.match(v)
+              v     = match[1] if match
+              v
+            end
+
+            guest_version = versions[0]
+            vb_version    = versions[1]
+
+            if guest_version != vb_version
+              env[:ui].warn(I18n.t("vagrant.actions.vm.check_guest_additions.version_mismatch",
+                                   :guest_version => version,
+                                   :virtualbox_version => vb_version))
+            end
+          end
+
+          # Continue
+          @app.call(env)
+        end
+
+      end
+    end
+  end
+end

data/plugins/providers/virtualbox/action/check_running.rb

@@ -0,0 +1,21 @@
+module VagrantPlugins
+  module ProviderVirtualBox
+    module Action
+      # This middleware checks that the VM is running, and raises an exception
+      # if it is not, notifying the user that the VM must be running.
+      class CheckRunning
+        def initialize(app, env)
+          @app = app
+        end
+
+        def call(env)
+          if env[:machine].state.id != :running
+            raise Vagrant::Errors::VMNotRunningError
+          end
+
+          @app.call(env)
+        end
+      end
+    end
+  end
+end

data/plugins/providers/virtualbox/action/check_virtualbox.rb

@@ -0,0 +1,22 @@
+module VagrantPlugins
+  module ProviderVirtualBox
+    module Action
+      # Checks that VirtualBox is installed and ready to be used.
+      class CheckVirtualbox
+        def initialize(app, env)
+          @app = app
+        end
+
+        def call(env)
+          # This verifies that VirtualBox is installed and the driver is
+          # ready to function. If not, then an exception will be raised
+          # which will break us out of execution of the middleware sequence.
+          Driver::Meta.new.verify!
+
+          # Carry on.
+          @app.call(env)
+        end
+      end
+    end
+  end
+end

data/plugins/providers/virtualbox/action/clean_machine_folder.rb

@@ -0,0 +1,43 @@
+require "fileutils"
+
+module VagrantPlugins
+  module ProviderVirtualBox
+    module Action
+      # Cleans up the VirtualBox machine folder for any ".xml-prev"
+      # files which VirtualBox may have left over. This is a bug in
+      # VirtualBox. As soon as this is fixed, this middleware can and
+      # will be removed.
+      class CleanMachineFolder
+        def initialize(app, env)
+          @app = app
+        end
+
+        def call(env)
+          clean_machine_folder(env[:machine].provider.driver.read_machine_folder)
+          @app.call(env)
+        end
+
+        def clean_machine_folder(machine_folder)
+          folder = File.join(machine_folder, "*")
+
+          # Small safeguard against potentially unwanted rm-rf, since the default
+          # machine folder will typically always be greater than 10 characters long.
+          # For users with it < 10, out of luck?
+          return if folder.length < 10
+
+          Dir[folder].each do |f|
+            next unless File.directory?(f)
+
+            keep = Dir["#{f}/**/*"].find do |d|
+              # Find a file that doesn't have ".xml-prev" as the suffix,
+              # which signals that we want to keep this folder
+              File.file?(d) && !(File.basename(d) =~ /\.vbox-prev$/)
+            end
+
+            FileUtils.rm_rf(f) if !keep
+          end
+        end
+      end
+    end
+  end
+end

data/plugins/providers/virtualbox/action/clear_forwarded_ports.rb

@@ -0,0 +1,18 @@
+module VagrantPlugins
+  module ProviderVirtualBox
+    module Action
+      class ClearForwardedPorts
+        def initialize(app, env)
+          @app = app
+        end
+
+        def call(env)
+          env[:ui].info I18n.t("vagrant.actions.vm.clear_forward_ports.deleting")
+          env[:machine].provider.driver.clear_forwarded_ports
+
+          @app.call(env)
+        end
+      end
+    end
+  end
+end

data/plugins/providers/virtualbox/action/clear_network_interfaces.rb

@@ -0,0 +1,31 @@
+module VagrantPlugins
+  module ProviderVirtualBox
+    module Action
+      class ClearNetworkInterfaces
+        def initialize(app, env)
+          @app = app
+        end
+
+        def call(env)
+          # Create the adapters array to make all adapters nothing.
+          # We do adapters 2 to 8 because that is every built-in adapter
+          # excluding the NAT adapter on port 1 which Vagrant always
+          # expects to exist.
+          adapters = []
+          2.upto(env[:machine].provider.driver.max_network_adapters).each do |i|
+            adapters << {
+              :adapter => i,
+              :type    => :none
+            }
+          end
+
+          # "Enable" all the adapters we setup.
+          env[:ui].info I18n.t("vagrant.actions.vm.clear_network_interfaces.deleting")
+          env[:machine].provider.driver.enable_adapters(adapters)
+
+          @app.call(env)
+        end
+      end
+    end
+  end
+end

data/plugins/providers/virtualbox/action/clear_shared_folders.rb

@@ -0,0 +1,17 @@
+module VagrantPlugins
+  module ProviderVirtualBox
+    module Action
+      class ClearSharedFolders
+        def initialize(app, env)
+          @app = app
+        end
+
+        def call(env)
+          env[:machine].provider.driver.clear_shared_folders
+
+          @app.call(env)
+        end
+      end
+    end
+  end
+end

data/plugins/providers/virtualbox/action/created.rb

@@ -0,0 +1,20 @@
+module VagrantPlugins
+  module ProviderVirtualBox
+    module Action
+      class Created
+        def initialize(app, env)
+          @app = app
+        end
+
+        def call(env)
+          # Set the result to be true if the machine is created.
+          env[:result] = env[:machine].state.id != :not_created
+
+          # Call the next if we have one (but we shouldn't, since this
+          # middleware is built to run with the Call-type middlewares)
+          @app.call(env)
+        end
+      end
+    end
+  end
+end

data/plugins/providers/virtualbox/action/customize.rb

@@ -0,0 +1,43 @@
+module VagrantPlugins
+  module ProviderVirtualBox
+    module Action
+      class Customize
+        def initialize(app, env, event)
+          @app = app
+          @event = event
+        end
+
+        def call(env)
+          customizations = []
+          env[:machine].provider_config.customizations.each do |event, command|
+            if event == @event
+              customizations << command
+            end
+          end
+
+          if !customizations.empty?
+            env[:ui].info I18n.t("vagrant.actions.vm.customize.running", event: @event)
+
+            # Execute each customization command.
+            customizations.each do |command|
+              processed_command = command.collect do |arg|
+                arg = env[:machine].id if arg == :id
+                arg.to_s
+              end
+
+              result = env[:machine].provider.driver.execute_command(processed_command)
+              if result.exit_code != 0
+                raise Vagrant::Errors::VMCustomizationFailed, {
+                  :command => processed_command.inspect,
+                  :error   => result.stderr
+                }
+              end
+            end
+          end
+
+          @app.call(env)
+        end
+      end
+    end
+  end
+end

data/plugins/providers/virtualbox/action/destroy.rb

@@ -0,0 +1,19 @@
+module VagrantPlugins
+  module ProviderVirtualBox
+    module Action
+      class Destroy
+        def initialize(app, env)
+          @app = app
+        end
+
+        def call(env)
+          env[:ui].info I18n.t("vagrant.actions.vm.destroy.destroying")
+          env[:machine].provider.driver.delete
+          env[:machine].id = nil
+
+          @app.call(env)
+        end
+      end
+    end
+  end
+end

data/plugins/providers/virtualbox/action/destroy_unused_network_interfaces.rb

@@ -0,0 +1,23 @@
+require "log4r"
+
+module VagrantPlugins
+  module ProviderVirtualBox
+    module Action
+      class DestroyUnusedNetworkInterfaces
+        def initialize(app, env)
+          @app = app
+          @logger = Log4r::Logger.new("vagrant::plugins::virtualbox::destroy_unused_netifs")
+        end
+
+        def call(env)
+          if env[:machine].provider_config.destroy_unused_network_interfaces
+            @logger.info("Destroying unused network interfaces...")
+            env[:machine].provider.driver.delete_unused_host_only_networks
+          end
+
+          @app.call(env)
+        end
+      end
+    end
+  end
+end

data/plugins/providers/virtualbox/action/discard_state.rb

@@ -0,0 +1,20 @@
+module VagrantPlugins
+  module ProviderVirtualBox
+    module Action
+      class DiscardState
+        def initialize(app, env)
+          @app = app
+        end
+
+        def call(env)
+          if env[:machine].provider.state.id == :saved
+            env[:ui].info I18n.t("vagrant.actions.vm.discard_state.discarding")
+            env[:machine].provider.driver.discard_saved_state
+          end
+
+           @app.call(env)
+        end
+      end
+    end
+  end
+end

data/plugins/providers/virtualbox/action/export.rb

@@ -0,0 +1,57 @@
+require "fileutils"
+
+module VagrantPlugins
+  module ProviderVirtualBox
+    module Action
+      class Export
+        attr_reader :temp_dir
+
+        def initialize(app, env)
+          @app = app
+        end
+
+        def call(env)
+          @env = env
+
+          raise Vagrant::Errors::VMPowerOffToPackage if \
+            @env[:machine].provider.state.id != :poweroff
+
+          setup_temp_dir
+          export
+
+          @app.call(env)
+
+          recover(env) # called to cleanup temp directory
+        end
+
+        def recover(env)
+          if temp_dir && File.exist?(temp_dir)
+            FileUtils.rm_rf(temp_dir)
+          end
+        end
+
+        def setup_temp_dir
+          @env[:ui].info I18n.t("vagrant.actions.vm.export.create_dir")
+          @temp_dir = @env["export.temp_dir"] = @env[:tmp_path].join(Time.now.to_i.to_s)
+          FileUtils.mkpath(@env["export.temp_dir"])
+        end
+
+        def export
+          @env[:ui].info I18n.t("vagrant.actions.vm.export.exporting")
+          @env[:machine].provider.driver.export(ovf_path) do |progress|
+            @env[:ui].clear_line
+            @env[:ui].report_progress(progress.percent, 100, false)
+          end
+
+          # Clear the line a final time so the next data can appear
+          # alone on the line.
+          @env[:ui].clear_line
+        end
+
+        def ovf_path
+          File.join(@env["export.temp_dir"], "box.ovf")
+        end
+      end
+    end
+  end
+end