nixme-vagrant 0.7.2

data/lib/vagrant/action/vm/forward_ports.rb

@@ -0,0 +1,133 @@
+require File.join(File.dirname(__FILE__), 'forward_ports_helpers')
+
+module Vagrant
+  class Action
+    module VM
+      class ForwardPorts
+        include ForwardPortsHelpers
+
+        def initialize(app,env)
+          @app = app
+          @env = env
+
+          threshold_check
+          external_collision_check
+        end
+
+        #--------------------------------------------------------------
+        # Prepare Helpers - These functions are not involved in actually
+        # executing the action
+        #--------------------------------------------------------------
+
+        # This method checks for any forwarded ports on the host below
+        # 1024, which causes the forwarded ports to fail.
+        def threshold_check
+          @env.env.config.vm.forwarded_ports.each do |name, options|
+            raise Errors::ForwardPortBelowThreshold if options[:hostport] <= 1024
+          end
+        end
+
+        # This method checks for any port collisions with any VMs
+        # which are already created (by Vagrant or otherwise).
+        # report the collisions detected or will attempt to fix them
+        # automatically if the port is configured to do so.
+        def external_collision_check
+          existing = used_ports
+          @env.env.config.vm.forwarded_ports.each do |name, options|
+            if existing.include?(options[:hostport].to_i)
+              handle_collision(name, options, existing)
+            end
+          end
+        end
+
+        # Handles any collisions. This method will either attempt to
+        # fix the collision automatically or will raise an error if
+        # auto fixing is disabled.
+        def handle_collision(name, options, existing_ports)
+          if !options[:auto]
+            # Auto fixing is disabled for this port forward, so we
+            # must throw an error so the user can fix it.
+            raise Errors::ForwardPortCollision, :name => name,
+                                                :host_port => options[:hostport].to_s,
+                                                :guest_port => options[:guestport].to_s
+          end
+
+          # Get the auto port range and get rid of the used ports and
+          # ports which are being used in other forwards so we're just
+          # left with available ports.
+          range = @env.env.config.vm.auto_port_range.to_a
+          range -= @env.env.config.vm.forwarded_ports.collect { |n, o| o[:hostport].to_i }
+          range -= existing_ports
+
+          if range.empty?
+            raise Errors::ForwardPortAutolistEmpty, :vm_name => @env["vm"].name,
+                                                    :name => name,
+                                                    :host_port => options[:hostport].to_s,
+                                                    :guest_port => options[:guestport].to_s
+          end
+
+          # Set the port up to be the first one and add that port to
+          # the used list.
+          options[:hostport] = range.shift
+          existing_ports << options[:hostport]
+
+          # Notify the user
+          @env.ui.info(I18n.t("vagrant.actions.vm.forward_ports.fixed_collision",
+                       :name => name,
+                       :new_port => options[:hostport]))
+        end
+
+        #--------------------------------------------------------------
+        # Execution
+        #--------------------------------------------------------------
+        def call(env)
+          @env = env
+
+          forward_ports
+
+          @app.call(env)
+        end
+
+        def forward_ports
+          @env.ui.info I18n.t("vagrant.actions.vm.forward_ports.forwarding")
+
+          @env.env.config.vm.forwarded_ports.each do |name, options|
+            adapter = options[:adapter]
+            message_attributes = {
+              :name => name,
+              :guest_port => options[:guestport],
+              :host_port => options[:hostport],
+              :adapter => adapter + 1
+            }
+
+            # Assuming the only reason to establish port forwarding is because the VM is using Virtualbox NAT networking.
+            # Host-only or Bridged networking don't require port-forwarding and establishing forwarded ports on these
+            # attachment types has uncertain behaviour.
+            if @env["vm"].vm.network_adapters[adapter].attachment_type == :nat
+              @env.ui.info(I18n.t("vagrant.actions.vm.forward_ports.forwarding_entry", message_attributes))
+              forward_port(name, options)
+            else
+              @env.ui.info(I18n.t("vagrant.actions.vm.forward_ports.non_nat", message_attributes))
+            end
+          end
+
+          @env["vm"].vm.save
+          @env["vm"].reload!
+        end
+
+        #--------------------------------------------------------------
+        # General Helpers
+        #--------------------------------------------------------------
+
+        # Forwards a port.
+        def forward_port(name, options)
+          port = VirtualBox::NATForwardedPort.new
+          port.name = name
+          port.guestport = options[:guestport]
+          port.hostport = options[:hostport]
+          @env["vm"].vm.network_adapters[options[:adapter]].nat_driver.forwarded_ports << port
+        end
+      end
+    end
+  end
+end

data/lib/vagrant/action/vm/forward_ports_helpers.rb

@@ -0,0 +1,28 @@
+module Vagrant
+  class Action
+    module VM
+      # Helper methods for forwarding ports. Requires that the environment
+      # is set to the `@env` instance variable.
+      module ForwardPortsHelpers
+        # Returns an array of used ports. This method is implemented
+        # differently depending on the VirtualBox version, but the
+        # behavior is the same.
+        #
+        # @return [Array<String>]
+        def used_ports
+          result = VirtualBox::VM.all.collect do |vm|
+            if vm.running? && vm.uuid != @env["vm"].uuid
+              vm.network_adapters.collect do |na|
+                na.nat_driver.forwarded_ports.collect do |fp|
+                  fp.hostport.to_i
+                end
+              end
+            end
+          end
+
+          result.flatten.uniq
+        end
+      end
+    end
+  end
+end

data/lib/vagrant/action/vm/halt.rb

@@ -0,0 +1,29 @@
+module Vagrant
+  class Action
+    module VM
+      class Halt
+        def initialize(app, env, options=nil)
+          @app = app
+          env.merge!(options || {})
+        end
+
+        def call(env)
+          if env["vm"].created? && env["vm"].vm.running?
+            env["vm"].system.halt if !env["force"]
+
+            if env["vm"].vm.state(true) != :powered_off
+              env.ui.info I18n.t("vagrant.actions.vm.halt.force")
+              env["vm"].vm.stop
+            end
+
+            # Sleep for a second to verify that the VM properly
+            # cleans itself up
+            sleep 1 if !env["vagrant.test"]
+          end
+
+          @app.call(env)
+        end
+      end
+    end
+  end
+end

data/lib/vagrant/action/vm/host_name.rb

@@ -0,0 +1,21 @@
+module Vagrant
+  class Action
+    module VM
+      class HostName
+        def initialize(app, env)
+          @app = app
+        end
+
+        def call(env)
+          @app.call(env)
+
+          host_name = env["config"].vm.host_name
+          if !host_name.nil?
+            env.ui.info I18n.t("vagrant.actions.vm.host_name.setting")
+            env["vm"].system.change_host_name(host_name)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/vagrant/action/vm/import.rb

@@ -0,0 +1,35 @@
+module Vagrant
+  class Action
+    module VM
+      class Import
+        def initialize(app, env)
+          @app = app
+        end
+
+        def call(env)
+          env.ui.info I18n.t("vagrant.actions.vm.import.importing", :name => env.env.box.name)
+
+          # Import the virtual machine
+          env.env.vm.vm = VirtualBox::VM.import(env.env.box.ovf_file.to_s) do |progress|
+            env.ui.report_progress(progress.percent, 100, false)
+          end
+
+          # Flag as erroneous and return if import failed
+          raise Errors::VMImportFailure if !env["vm"].vm
+
+          # Import completed successfully. Continue the chain
+          @app.call(env)
+        end
+
+        def recover(env)
+          if env["vm"].created?
+            return if env["vagrant.error"].is_a?(Errors::VagrantError)
+
+            # Interrupted, destroy the VM
+            env["actions"].run(:destroy)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/vagrant/action/vm/match_mac_address.rb

@@ -0,0 +1,21 @@
+module Vagrant
+  class Action
+    module VM
+      class MatchMACAddress
+        def initialize(app, env)
+          @app = app
+        end
+
+        def call(env)
+          raise Errors::VMBaseMacNotSpecified if !env.env.config.vm.base_mac
+
+          env.ui.info I18n.t("vagrant.actions.vm.match_mac.matching")
+          env["vm"].vm.network_adapters.first.mac_address = env.env.config.vm.base_mac
+          env["vm"].vm.save
+
+          @app.call(env)
+        end
+      end
+    end
+  end
+end

data/lib/vagrant/action/vm/network.rb

@@ -0,0 +1,139 @@
+module Vagrant
+  class Action
+    module VM
+      # Networking middleware for Vagrant. This enables host only
+      # networking on VMs if configured as such.
+      class Network
+        def initialize(app, env)
+          @app = app
+          @env = env
+
+          if enable_network? && Util::Platform.windows? && Util::Platform.bit64?
+            raise Errors::NetworkNotImplemented
+          end
+
+          env["config"].vm.network_options.compact.each do |network_options|
+            raise Errors::NetworkCollision if !verify_no_bridge_collision(network_options)
+          end
+        end
+
+        def call(env)
+          @env = env
+          assign_network if enable_network?
+
+          @app.call(env)
+
+          if enable_network?
+            @env.ui.info I18n.t("vagrant.actions.vm.network.enabling")
+            @env.env.config.vm.network_options.compact.each do |network_options|
+              @env["vm"].system.prepare_host_only_network(network_options)
+              @env["vm"].system.enable_host_only_network(network_options)
+            end
+          end
+        end
+
+        # Verifies that there is no collision with a bridged network interface
+        # for the given network options.
+        def verify_no_bridge_collision(net_options)
+          interfaces = VirtualBox::Global.global.host.network_interfaces
+          interfaces.each do |ni|
+            next if ni.interface_type == :host_only
+
+            result = if net_options[:name]
+              true if net_options[:name] == ni.name
+            else
+              true if matching_network?(ni, net_options)
+            end
+
+            return false if result
+          end
+
+          true
+        end
+
+        def enable_network?
+          !@env.env.config.vm.network_options.compact.empty?
+        end
+
+        # Enables and assigns the host only network to the proper
+        # adapter on the VM, and saves the adapter.
+        def assign_network
+          @env.ui.info I18n.t("vagrant.actions.vm.network.preparing")
+
+          @env.env.config.vm.network_options.compact.each do |network_options|
+            adapter = @env["vm"].vm.network_adapters[network_options[:adapter]]
+            adapter.enabled = true
+            adapter.attachment_type = :host_only
+            adapter.host_interface = network_name(network_options)
+            adapter.mac_address = network_options[:mac].gsub(':', '') if network_options[:mac]
+            adapter.save
+          end
+        end
+
+        # Returns the name of the proper host only network, or creates
+        # it if it does not exist. Vagrant determines if the host only
+        # network exists by comparing the netmask and the IP.
+        def network_name(net_options)
+          # First try to find a matching network
+          interfaces = VirtualBox::Global.global.host.network_interfaces
+          interfaces.each do |ni|
+            # Ignore non-host only interfaces which may also match,
+            # since they're not valid options.
+            next if ni.interface_type != :host_only
+
+            if net_options[:name]
+              return ni.name if net_options[:name] == ni.name
+            else
+              return ni.name if matching_network?(ni, net_options)
+            end
+          end
+
+          raise Errors::NetworkNotFound, :name => net_options[:name] if net_options[:name]
+
+          # One doesn't exist, create it.
+          @env.ui.info I18n.t("vagrant.actions.vm.network.creating")
+
+          ni = interfaces.create
+          ni.enable_static(network_ip(net_options[:ip], net_options[:netmask]),
+                           net_options[:netmask])
+          ni.name
+        end
+
+        # Tests if a network matches the given options by applying the
+        # netmask to the IP of the network and also to the IP of the
+        # virtual machine and see if they match.
+        def matching_network?(interface, net_options)
+          interface.network_mask == net_options[:netmask] &&
+            apply_netmask(interface.ip_address, interface.network_mask) ==
+            apply_netmask(net_options[:ip], net_options[:netmask])
+        end
+
+        # Applies a netmask to an IP and returns the corresponding
+        # parts.
+        def apply_netmask(ip, netmask)
+          ip = split_ip(ip)
+          netmask = split_ip(netmask)
+
+          ip.map do |part|
+            part & netmask.shift
+          end
+        end
+
+        # Splits an IP and converts each portion into an int.
+        def split_ip(ip)
+          ip.split(".").map do |i|
+            i.to_i
+          end
+        end
+
+        # Returns a "network IP" which is a "good choice" for the IP
+        # for the actual network based on the netmask.
+        def network_ip(ip, netmask)
+          parts = apply_netmask(ip, netmask)
+          parts[3] += 1;
+          parts.join(".")
+        end
+      end
+    end
+  end
+end

data/lib/vagrant/action/vm/nfs.rb

@@ -0,0 +1,159 @@
+require File.expand_path("../nfs_helpers", __FILE__)
+
+module Vagrant
+  class Action
+    module VM
+      # Enables NFS based shared folders. `nfsd` must already be installed
+      # on the host machine, and NFS client must already be installed on
+      # the guest machine.
+      #
+      # This is a two part process:
+      #
+      #   1. Adds an entry to `/etc/exports` on the host machine using
+      #      the host class to export the proper folder to the proper
+      #      machine.
+      #   2. After boot, runs `mount` on the guest to mount the shared
+      #      folder.
+      #
+      class NFS
+        include NFSHelpers
+
+        def initialize(app,env)
+          @app = app
+          @env = env
+
+          verify_settings if nfs_enabled?
+        end
+
+        def call(env)
+          @env = env
+
+          extract_folders
+
+          if !folders.empty?
+            prepare_folders
+            clear_nfs_exports(env)
+            export_folders
+          end
+
+          @app.call(env)
+
+          mount_folders if !folders.empty?
+        end
+
+        def recover(env)
+          clear_nfs_exports(env) if env["vm"].created?
+        end
+
+        # Returns the folders which are to be synced via NFS.
+        def folders
+          @folders ||= {}
+        end
+
+        # Removes the NFS enabled shared folders from the configuration,
+        # so they will no longer be mounted by the actual shared folder
+        # task.
+        def extract_folders
+          # Load the NFS enabled shared folders
+          @folders = @env["config"].vm.shared_folders.inject({}) do |acc, data|
+            key, opts = data
+
+            if opts[:nfs]
+              # Duplicate the options, set the hostpath, and set disabled on the original
+              # options so the ShareFolders middleware doesn't try to mount it.
+              acc[key] = opts.dup
+              acc[key][:hostpath] = File.expand_path(opts[:hostpath], @env.env.root_path)
+              opts[:disabled] = true
+            end
+
+            acc
+          end
+        end
+
+        # Prepares the settings for the NFS folders, such as setting the
+        # options on the NFS folders.
+        def prepare_folders
+          @folders = @folders.inject({}) do |acc, data|
+            key, opts = data
+            opts[:nfs] = {} if !opts.is_a?(Hash)
+            opts[:map_uid] = prepare_permission(:uid, opts)
+            opts[:map_gid] = prepare_permission(:gid, opts)
+
+            acc[key] = opts
+            acc
+          end
+        end
+
+        # Prepares the UID/GID settings for a single folder.
+        def prepare_permission(perm, opts)
+          key = "map_#{perm}".to_sym
+          return nil if opts.has_key?(key) && opts[key].nil?
+
+          # The options on the hash get priority, then the default
+          # values
+          value = opts.has_key?(key) ? opts[key] : @env["config"].nfs.send(key)
+          return value if value != :auto
+
+          # Get UID/GID from folder if we've made it this far
+          # (value == :auto)
+          stat = File.stat(opts[:hostpath])
+          return stat.send(perm)
+        end
+
+        # Uses the host class to export the folders via NFS. This typically
+        # involves adding a line to `/etc/exports` for this VM, but it is
+        # up to the host class to define the specific behavior.
+        def export_folders
+          @env.ui.info I18n.t("vagrant.actions.vm.nfs.exporting")
+
+          @env["host"].nfs_export(guest_ip, folders)
+        end
+
+        # Uses the system class to mount the NFS folders.
+        def mount_folders
+          @env.ui.info I18n.t("vagrant.actions.vm.nfs.mounting")
+
+          # Only mount the folders which have a guest path specified
+          am_folders = folders.select { |name, folder| folder[:guestpath] }
+          @env["vm"].system.mount_nfs(host_ip, Hash[am_folders])
+        end
+
+        # Returns the IP address of the first host only network adapter
+        #
+        # @return [String]
+        def host_ip
+          interface = @env["vm"].vm.network_adapters.find do |adapter|
+            adapter.host_interface_object
+          end
+
+          return nil if !interface
+          interface.host_interface_object.ip_address
+        end
+
+        # Returns the IP address of the guest by looking at the first
+        # enabled host only network.
+        #
+        # @return [String]
+        def guest_ip
+          @env["config"].vm.network_options[1][:ip]
+        end
+
+        # Checks if there are any NFS enabled shared folders.
+        def nfs_enabled?
+          @env["config"].vm.shared_folders.each do |key, opts|
+            return true if opts[:nfs]
+          end
+
+          false
+        end
+
+        # Verifies that the host is set and supports NFS.
+        def verify_settings
+          raise Errors::NFSHostRequired if @env["host"].nil?
+          raise Errors::NFSNotSupported if !@env["host"].nfs?
+          raise Errors::NFSNoHostNetwork if @env["config"].vm.network_options.empty?
+        end
+      end
+    end
+  end
+end