vagrant-vmware-free 0.0.1

data/lib/vagrant_vmware_free/action/check_running.rb

@@ -0,0 +1,21 @@
+module VagrantPlugins
+  module ProviderVMwareFree
+    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_vmware_free/action/check_virtualbox.rb

@@ -0,0 +1,22 @@
+module VagrantPlugins
+  module ProviderVMwareFree
+    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/lib/vagrant_vmware_free/action/clean_machine_folder.rb

@@ -0,0 +1,43 @@
+require "fileutils"
+
+module VagrantPlugins
+  module ProviderVMwareFree
+    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/lib/vagrant_vmware_free/action/clear_forwarded_ports.rb

@@ -0,0 +1,18 @@
+module VagrantPlugins
+  module ProviderVMwareFree
+    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/lib/vagrant_vmware_free/action/clear_network_interfaces.rb

@@ -0,0 +1,31 @@
+module VagrantPlugins
+  module ProviderVMwareFree
+    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_vmware_free/action/clear_shared_folders.rb

@@ -0,0 +1,17 @@
+module VagrantPlugins
+  module ProviderVMwareFree
+    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/lib/vagrant_vmware_free/action/created.rb

@@ -0,0 +1,20 @@
+module VagrantPlugins
+  module ProviderVMwareFree
+    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_vmware_free/action/customize.rb

@@ -0,0 +1,43 @@
+module VagrantPlugins
+  module ProviderVMwareFree
+    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/lib/vagrant_vmware_free/action/destroy.rb

@@ -0,0 +1,19 @@
+module VagrantPlugins
+  module ProviderVMwareFree
+    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_vmware_free/action/destroy_unused_network_interfaces.rb

@@ -0,0 +1,23 @@
+require "log4r"
+
+module VagrantPlugins
+  module ProviderVMwareFree
+    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/lib/vagrant_vmware_free/action/discard_state.rb

@@ -0,0 +1,20 @@
+module VagrantPlugins
+  module ProviderVMwareFree
+    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/lib/vagrant_vmware_free/action/export.rb

@@ -0,0 +1,57 @@
+require "fileutils"
+
+module VagrantPlugins
+  module ProviderVMwareFree
+    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/lib/vagrant_vmware_free/action/forced_halt.rb

@@ -0,0 +1,25 @@
+module VagrantPlugins
+  module ProviderVMwareFree
+    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_vmware_free/action/forward_ports.rb

@@ -0,0 +1,89 @@
+module VagrantPlugins
+  module ProviderVMwareFree
+    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,
+              :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