vagrant-veertu 0.0.12

data/lib/vagrant-veertu/action/check_accessible.rb

@@ -0,0 +1,22 @@
+module VagrantPlugins
+  module ProviderVeertu
+    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/lib/vagrant-veertu/action/check_created.rb

@@ -0,0 +1,21 @@
+module VagrantPlugins
+  module ProviderVeertu
+    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/lib/vagrant-veertu/action/check_running.rb

@@ -0,0 +1,21 @@
+module VagrantPlugins
+  module ProviderVeertu
+    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/lib/vagrant-veertu/action/check_veertu.rb

@@ -0,0 +1,22 @@
+module VagrantPlugins
+  module ProviderVeertu
+    module Action
+      # Checks that VirtualBox is installed and ready to be used.
+      class CheckVeertu
+        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/lib/vagrant-veertu/action/clear_forwarded_ports.rb

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

data/lib/vagrant-veertu/action/clear_network_interfaces.rb

@@ -0,0 +1,31 @@
+module VagrantPlugins
+  module ProviderVeertu
+    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/lib/vagrant-veertu/action/created.rb

@@ -0,0 +1,20 @@
+module VagrantPlugins
+  module ProviderVeertu
+    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/lib/vagrant-veertu/action/customize.rb

@@ -0,0 +1,44 @@
+module VagrantPlugins
+  module ProviderVeertu
+    module Action
+      class Customize
+        def initialize(app, env, event)
+          @app = app
+          @event = event
+        end
+
+        def call(env)
+          puts 'running customize'
+          
+          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
+
+              begin
+                env[:machine].provider.driver.execute_command(
+                  processed_command + [retryable: true])
+              rescue Vagrant::Errors::VBoxManageError => e
+                raise Vagrant::Errors::VMCustomizationFailed, {
+                  command: command,
+                  error:   e.inspect
+                }
+              end
+            end
+          end
+          @app.call(env)
+        end
+      end
+    end
+  end
+end

data/lib/vagrant-veertu/action/destroy.rb

@@ -0,0 +1,19 @@
+module VagrantPlugins
+  module ProviderVeertu
+    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/lib/vagrant-veertu/action/discard_state.rb

@@ -0,0 +1,20 @@
+module VagrantPlugins
+  module ProviderVeertu
+    module Action
+      class DiscardState
+        def initialize(app, env)
+          @app = app
+        end
+
+        def call(env)
+          if env[:machine].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/lib/vagrant-veertu/action/export.rb

@@ -0,0 +1,41 @@
+require "fileutils"
+
+module VagrantPlugins
+  module ProviderVeertu
+    module Action
+      class Export
+        def initialize(app, env)
+          @app = app
+        end
+
+        def call(env)
+          @env = env
+
+	  #env[:ui].output(@env[:machine].state.id)
+          raise Vagrant::Errors::VMPowerOffToPackage if \
+            @env[:machine].state.id != :stopped
+
+          export
+
+          @app.call(env)
+        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/lib/vagrant-veertu/action/forced_halt.rb

@@ -0,0 +1,25 @@
+module VagrantPlugins
+  module ProviderVeertu
+    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/lib/vagrant-veertu/action/forward_ports.rb

@@ -0,0 +1,91 @@
+require 'log4r'
+module VagrantPlugins
+  module ProviderVeertu
+    module Action
+      class ForwardPorts
+        include Util::CompileForwardedPorts
+
+        def initialize(app, env)
+          @app = app
+          @logger = Log4r::Logger.new("vagrant::provider::veertu_5_0")
+        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].output(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].detail(I18n.t("vagrant.actions.vm.forward_ports.forwarding_entry",
+                                    message_attributes))
+            @logger.debug(YAML::dump(fp))
+            # 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].detail(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,
+              guestip:   fp.guest_ip,
+              guestport: fp.guest_port,
+              hostip:    fp.host_ip,
+              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

data/lib/vagrant-veertu/action/import.rb

@@ -0,0 +1,96 @@
+module VagrantPlugins
+  module ProviderVeertu
+    module Action
+      class Import
+        def initialize(app, env)
+          @app = app
+        end
+
+        def call(env)
+          if env[:clone_id]
+            clone(env)
+          else
+            import(env)
+          end
+        end
+
+        def clone(env)
+          # Do the actual clone
+          env[:ui].info I18n.t("vagrant.actions.vm.clone.creating")
+          env[:machine].id = env[:machine].provider.driver.clonevm(
+            env[:clone_id], env[:clone_snapshot]) do |progress|
+            env[:ui].clear_line
+            env[:ui].report_progress(progress, 100, false)
+          end
+
+          # Clear the line one last time since the progress meter doesn't
+          # disappear immediately.
+          env[:ui].clear_line
+
+          # Flag as erroneous and return if clone failed
+          raise Vagrant::Errors::VMCloneFailure if !env[:machine].id
+
+          # Copy the SSH key from the clone machine if we can
+          if env[:clone_machine]
+            key_path = env[:clone_machine].data_dir.join("private_key")
+            if key_path.file?
+              FileUtils.cp(
+                key_path,
+                env[:machine].data_dir.join("private_key"))
+            end
+          end
+
+          # Continue
+          @app.call(env)
+        end
+
+        def import(env)
+          env[:ui].info I18n.t("vagrant.actions.vm.import.importing",
+                               name: env[:machine].box.name)
+
+          # Import the virtual machine
+          ovf_file = env[:machine].box.directory.join("box.vmz").to_s
+          id = env[:machine].provider.driver.import(ovf_file) do |progress|
+            env[:ui].clear_line
+            env[:ui].report_progress(progress, 100, false)
+          end
+
+          # Set the machine ID
+          env[:machine_id] = id
+          env[:machine].id = id if !env[:skip_machine]
+
+          # Clear the line one last time since the progress meter doesn't disappear
+          # immediately.
+          env[:ui].clear_line
+
+          # If we got interrupted, then the import could have been
+          # interrupted and its not a big deal. Just return out.
+          return if env[:interrupted]
+
+          # Flag as erroneous and return if import failed
+          raise Vagrant::Errors::VMImportFailure if !id
+
+          # Import completed successfully. Continue the chain
+          @app.call(env)
+        end
+
+        def recover(env)
+          if env[:machine] && env[:machine].state.id != :not_created
+            return if env["vagrant.error"].is_a?(Vagrant::Errors::VagrantError)
+
+            # If we're not supposed to destroy on error then just return
+            return if !env[:destroy_on_error]
+
+            # Interrupted, destroy the VM. We note that we don't want to
+            # validate the configuration here, and we don't want to confirm
+            # we want to destroy.
+            destroy_env = env.clone
+            destroy_env[:config_validate] = false
+            destroy_env[:force_confirm_destroy] = true
+            env[:action_runner].run(Action.action_destroy, destroy_env)
+          end
+        end
+      end
+    end
+  end
+end