tnargav 1.2.2

data/plugins/kernel_v2/config/vm_subvm.rb

@@ -0,0 +1,30 @@
+require "vagrant/util/stacked_proc_runner"
+
+module VagrantPlugins
+  module Kernel_V2
+    # Represents a single sub-VM in a multi-VM environment.
+    class VagrantConfigSubVM
+      include Vagrant::Util::StackedProcRunner
+
+      # Returns an array of the configuration procs in [version, proc]
+      # format.
+      #
+      # @return [Array]
+      attr_reader :config_procs
+
+      attr_reader :options
+
+      def initialize
+        @config_procs = []
+        @options      = {}
+      end
+
+      def initialize_copy(other)
+        super
+
+        @config_procs = other.config_procs.clone
+        @options      = other.options.clone
+      end
+    end
+  end
+end

data/plugins/kernel_v2/plugin.rb

@@ -0,0 +1,44 @@
+require "vagrant"
+
+module VagrantPlugins
+  module Kernel_V2
+    # This is the "kernel" of Vagrant and contains the configuration classes
+    # that make up the core of Vagrant for V2.
+    class Plugin < Vagrant.plugin("2")
+      name "kernel"
+      description <<-DESC
+      The kernel of Vagrant. This plugin contains required items for even
+      basic functionality of Vagrant version 2.
+      DESC
+
+      # Core configuration keys provided by the kernel. Note that unlike
+      # "kernel_v1", none of these configuration classes are upgradable.
+      # This is by design, since we can't be sure if they're upgradable
+      # until another version is available.
+      config("ssh") do
+        require File.expand_path("../config/ssh", __FILE__)
+        SSHConfig
+      end
+
+      config("nfs") do
+        require File.expand_path("../config/nfs", __FILE__)
+        NFSConfig
+      end
+
+      config("package") do
+        require File.expand_path("../config/package", __FILE__)
+        PackageConfig
+      end
+
+      config("vagrant") do
+        require File.expand_path("../config/vagrant", __FILE__)
+        VagrantConfig
+      end
+
+      config("vm") do
+        require File.expand_path("../config/vm", __FILE__)
+        VMConfig
+      end
+    end
+  end
+end

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

@@ -0,0 +1,49 @@
+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)
+          raise Vagrant::Errors::VMFailedToBoot if !wait_for_boot
+
+          @app.call(env)
+        end
+
+        def wait_for_boot
+          @env[:ui].info I18n.t("vagrant.actions.vm.boot.waiting")
+
+          @env[:machine].config.ssh.max_tries.to_i.times do |i|
+            if @env[:machine].communicate.ready?
+              @env[:ui].info I18n.t("vagrant.actions.vm.boot.ready")
+              return true
+            end
+
+            # Return true so that the vm_failed_to_boot error doesn't
+            # get shown
+            return true if @env[:interrupted]
+
+            # If the VM is not starting or running, something went wrong
+            # and we need to show a useful error.
+            state = @env[:machine].provider.state.id
+            raise Vagrant::Errors::VMFailedToRun if state != :starting && state != :running
+
+            sleep 2 if !@env["vagrant.test"]
+          end
+
+          @env[:ui].error I18n.t("vagrant.actions.vm.boot.failed")
+          false
+        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(8).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,36 @@
+module VagrantPlugins
+  module ProviderVirtualBox
+    module Action
+      class Customize
+        def initialize(app, env)
+          @app = app
+        end
+
+        def call(env)
+          customizations = env[:machine].provider_config.customizations
+          if !customizations.empty?
+            env[:ui].info I18n.t("vagrant.actions.vm.customize.running")
+
+            # 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,16 @@
+module VagrantPlugins
+  module ProviderVirtualBox
+    module Action
+      class DestroyUnusedNetworkInterfaces
+        def initialize(app, env)
+          @app = app
+        end
+
+        def call(env)
+          env[:machine].provider.driver.delete_unused_host_only_networks
+          @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

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

@@ -0,0 +1,25 @@
+module VagrantPlugins
+  module ProviderVirtualBox
+    module Action
+      class ForcedHalt
+        def initialize(app, env)
+          @app = app
+        end
+
+        def call(env)
+          current_state = env[:machine].state.id
+          if current_state == :running || current_state == :gurumeditation
+            env[:ui].info I18n.t("vagrant.actions.vm.halt.force")
+            env[:machine].provider.driver.halt
+          end
+
+          # Sleep for a second to verify that the VM properly
+          # cleans itself up. Silly VirtualBox.
+          sleep 1 if !env["vagrant.test"]
+
+          @app.call(env)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,87 @@
+module VagrantPlugins
+  module ProviderVirtualBox
+    module Action
+      class ForwardPorts
+        include Util::CompileForwardedPorts
+
+        def initialize(app, env)
+          @app = app
+        end
+
+        #--------------------------------------------------------------
+        # Execution
+        #--------------------------------------------------------------
+        def call(env)
+          @env = env
+
+          # Get the ports we're forwarding
+          env[:forwarded_ports] ||= compile_forwarded_ports(env[:machine].config)
+
+          # Warn if we're port forwarding to any privileged ports...
+          env[:forwarded_ports].each do |fp|
+            if fp.host_port <= 1024
+              env[:ui].warn I18n.t("vagrant.actions.vm.forward_ports.privileged_ports")
+              break
+            end
+          end
+
+          env[:ui].info I18n.t("vagrant.actions.vm.forward_ports.forwarding")
+          forward_ports
+
+          @app.call(env)
+        end
+
+        def forward_ports
+          ports = []
+
+          interfaces = @env[:machine].provider.driver.read_network_interfaces
+
+          @env[:forwarded_ports].each do |fp|
+            message_attributes = {
+              :adapter => fp.adapter,
+              :guest_port => fp.guest_port,
+              :host_port => fp.host_port
+            }
+
+            # Assuming the only reason to establish port forwarding is
+            # because the VM is using Virtualbox NAT networking. Host-only
+            # bridged networking don't require port-forwarding and establishing
+            # forwarded ports on these attachment types has uncertain behaviour.
+            @env[:ui].info(I18n.t("vagrant.actions.vm.forward_ports.forwarding_entry",
+                                    message_attributes))
+
+            # Verify we have the network interface to attach to
+            if !interfaces[fp.adapter]
+              raise Vagrant::Errors::ForwardPortAdapterNotFound,
+                :adapter => fp.adapter.to_s,
+                :guest => fp.guest_port.to_s,
+                :host => fp.host_port.to_s
+            end
+
+            # Port forwarding requires the network interface to be a NAT interface,
+            # so verify that that is the case.
+            if interfaces[fp.adapter][:type] != :nat
+              @env[:ui].info(I18n.t("vagrant.actions.vm.forward_ports.non_nat",
+                                    message_attributes))
+              next
+            end
+
+            # Add the options to the ports array to send to the driver later
+            ports << {
+              :adapter   => fp.adapter,
+              :guestport => fp.guest_port,
+              :hostport  => fp.host_port,
+              :name      => fp.id,
+              :protocol  => fp.protocol
+            }
+          end
+
+          if !ports.empty?
+            # We only need to forward ports if there are any to forward
+            @env[:machine].provider.driver.forward_ports(ports)
+          end
+        end
+      end
+    end
+  end
+end