tnargav 1.3.5 → 1.3.6

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,89 @@
+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,
+              :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/plugins/providers/virtualbox/action/import.rb

@@ -0,0 +1,54 @@
+module VagrantPlugins
+  module ProviderVirtualBox
+    module Action
+      class Import
+        def initialize(app, env)
+          @app = app
+        end
+
+        def call(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.ovf").to_s
+          env[:machine].id = env[:machine].provider.driver.import(ovf_file) 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
+
+          # 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 !env[:machine].id
+
+          # Import completed successfully. Continue the chain
+          @app.call(env)
+        end
+
+        def recover(env)
+          if env[:machine].provider.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

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

@@ -0,0 +1,20 @@
+module VagrantPlugins
+  module ProviderVirtualBox
+    module Action
+      class IsPaused
+        def initialize(app, env)
+          @app = app
+        end
+
+        def call(env)
+          # Set the result to be true if the machine is paused.
+          env[:result] = env[:machine].state.id == :paused
+
+          # 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/is_running.rb

@@ -0,0 +1,20 @@
+module VagrantPlugins
+  module ProviderVirtualBox
+    module Action
+      class IsRunning
+        def initialize(app, env)
+          @app = app
+        end
+
+        def call(env)
+          # Set the result to be true if the machine is running.
+          env[:result] = env[:machine].state.id == :running
+
+          # 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/is_saved.rb

@@ -0,0 +1,20 @@
+module VagrantPlugins
+  module ProviderVirtualBox
+    module Action
+      class IsSaved
+        def initialize(app, env)
+          @app = app
+        end
+
+        def call(env)
+          # Set the result to be true if the machine is saved.
+          env[:result] = env[:machine].state.id == :saved
+
+          # 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/match_mac_address.rb

@@ -0,0 +1,21 @@
+module VagrantPlugins
+  module ProviderVirtualBox
+    module Action
+      class MatchMACAddress
+        def initialize(app, env)
+          @app = app
+        end
+
+        def call(env)
+          raise Vagrant::Errors::VMBaseMacNotSpecified if !env[:machine].config.vm.base_mac
+
+          # Create the proc which we want to use to modify the virtual machine
+          env[:ui].info I18n.t("vagrant.actions.vm.match_mac.matching")
+          env[:machine].provider.driver.set_mac_address(env[:machine].config.vm.base_mac)
+
+          @app.call(env)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,16 @@
+module VagrantPlugins
+  module ProviderVirtualBox
+    module Action
+      class MessageAlreadyRunning
+        def initialize(app, env)
+          @app = app
+        end
+
+        def call(env)
+          env[:ui].info I18n.t("vagrant.commands.common.vm_already_running")
+          @app.call(env)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,16 @@
+module VagrantPlugins
+  module ProviderVirtualBox
+    module Action
+      class MessageNotCreated
+        def initialize(app, env)
+          @app = app
+        end
+
+        def call(env)
+          env[:ui].info I18n.t("vagrant.commands.common.vm_not_created")
+          @app.call(env)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,16 @@
+module VagrantPlugins
+  module ProviderVirtualBox
+    module Action
+      class MessageNotRunning
+        def initialize(app, env)
+          @app = app
+        end
+
+        def call(env)
+          env[:ui].info I18n.t("vagrant.commands.common.vm_not_running")
+          @app.call(env)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,17 @@
+module VagrantPlugins
+  module ProviderVirtualBox
+    module Action
+      class MessageWillNotDestroy
+        def initialize(app, env)
+          @app = app
+        end
+
+        def call(env)
+          env[:ui].info I18n.t("vagrant.commands.destroy.will_not_destroy",
+                              :name => env[:machine].name)
+          @app.call(env)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,424 @@
+require "set"
+
+require "log4r"
+
+require "vagrant/util/network_ip"
+require "vagrant/util/scoped_hash_override"
+
+module VagrantPlugins
+  module ProviderVirtualBox
+    module Action
+      # This middleware class sets up all networking for the VirtualBox
+      # instance. This includes host only networks, bridged networking,
+      # forwarded ports, etc.
+      #
+      # This handles all the `config.vm.network` configurations.
+      class Network
+        include Vagrant::Util::NetworkIP
+        include Vagrant::Util::ScopedHashOverride
+
+        def initialize(app, env)
+          @logger = Log4r::Logger.new("vagrant::plugins::virtualbox::network")
+          @app    = app
+        end
+
+        def call(env)
+          # TODO: Validate network configuration prior to anything below
+          @env = env
+
+          # Get the list of network adapters from the configuration
+          network_adapters_config = env[:machine].provider_config.network_adapters.dup
+
+          # Assign the adapter slot for each high-level network
+          available_slots = Set.new(1..8)
+          network_adapters_config.each do |slot, _data|
+            available_slots.delete(slot)
+          end
+
+          @logger.debug("Available slots for high-level adapters: #{available_slots.inspect}")
+          @logger.info("Determining network adapters required for high-level configuration...")
+          available_slots = available_slots.to_a.sort
+          env[:machine].config.vm.networks.each do |type, options|
+            # We only handle private and public networks
+            next if type != :private_network && type != :public_network
+
+            options = scoped_hash_override(options, :virtualbox)
+
+            # Figure out the slot that this adapter will go into
+            slot = options[:adapter]
+            if !slot
+              if available_slots.empty?
+                raise Vagrant::Errors::VirtualBoxNoRoomForHighLevelNetwork
+              end
+
+              slot = available_slots.shift
+            end
+
+            # Configure it
+            data = nil
+            if type == :private_network
+              # private_network = hostonly
+              data        = [:hostonly, options]
+            elsif type == :public_network
+              # public_network = bridged
+              data        = [:bridged, options]
+            end
+
+            # Store it!
+            @logger.info(" -- Slot #{slot}: #{data[0]}")
+            network_adapters_config[slot] = data
+          end
+
+          @logger.info("Determining adapters and compiling network configuration...")
+          adapters = []
+          networks = []
+          network_adapters_config.each do |slot, data|
+            type    = data[0]
+            options = data[1]
+
+            @logger.info("Network slot #{slot}. Type: #{type}.")
+
+            # Get the normalized configuration for this type
+            config = send("#{type}_config", options)
+            config[:adapter] = slot
+            @logger.debug("Normalized configuration: #{config.inspect}")
+
+            # Get the VirtualBox adapter configuration
+            adapter = send("#{type}_adapter", config)
+            adapters << adapter
+            @logger.debug("Adapter configuration: #{adapter.inspect}")
+
+            # Get the network configuration
+            network = send("#{type}_network_config", config)
+            network[:auto_config] = config[:auto_config]
+            networks << network
+          end
+
+          if !adapters.empty?
+            # Enable the adapters
+            @logger.info("Enabling adapters...")
+            env[:ui].info I18n.t("vagrant.actions.vm.network.preparing")
+            env[:machine].provider.driver.enable_adapters(adapters)
+          end
+
+          # Continue the middleware chain.
+          @app.call(env)
+
+          # If we have networks to configure, then we configure it now, since
+          # that requires the machine to be up and running.
+          if !adapters.empty? && !networks.empty?
+            assign_interface_numbers(networks, adapters)
+
+            # Only configure the networks the user requested us to configure
+            networks_to_configure = networks.select { |n| n[:auto_config] }
+            if !networks_to_configure.empty?
+              env[:ui].info I18n.t("vagrant.actions.vm.network.configuring")
+              env[:machine].guest.capability(:configure_networks, networks_to_configure)
+            end
+          end
+        end
+
+        def bridged_config(options)
+          return {
+            :auto_config                     => true,
+            :bridge                          => nil,
+            :mac                             => nil,
+            :nic_type                        => nil,
+            :use_dhcp_assigned_default_route => false
+          }.merge(options || {})
+        end
+
+        def bridged_adapter(config)
+          # Find the bridged interfaces that are available
+          bridgedifs = @env[:machine].provider.driver.read_bridged_interfaces
+          bridgedifs.delete_if { |interface| interface[:status] == "Down" }
+
+          # The name of the chosen bridge interface will be assigned to this
+          # variable.
+          chosen_bridge = nil
+
+          if config[:bridge]
+            @logger.debug("Bridge was directly specified in config, searching for: #{config[:bridge]}")
+
+            # Search for a matching bridged interface
+            bridgedifs.each do |interface|
+              if interface[:name].downcase == config[:bridge].downcase
+                @logger.debug("Specific bridge found as configured in the Vagrantfile. Using it.")
+                chosen_bridge = interface[:name]
+                break
+              end
+            end
+
+            # If one wasn't found, then we notify the user here.
+            if !chosen_bridge
+              @env[:ui].info I18n.t("vagrant.actions.vm.bridged_networking.specific_not_found",
+                                    :bridge => config[:bridge])
+            end
+          end
+
+          # If we still don't have a bridge chosen (this means that one wasn't
+          # specified in the Vagrantfile, or the bridge specified in the Vagrantfile
+          # wasn't found), then we fall back to the normal means of searchign for a
+          # bridged network.
+          if !chosen_bridge
+            if bridgedifs.length == 1
+              # One bridgable interface? Just use it.
+              chosen_bridge = bridgedifs[0][:name]
+              @logger.debug("Only one bridged interface available. Using it by default.")
+            else
+              # More than one bridgable interface requires a user decision, so
+              # show options to choose from.
+              @env[:ui].info I18n.t("vagrant.actions.vm.bridged_networking.available",
+                                    :prefix => false)
+              bridgedifs.each_index do |index|
+                interface = bridgedifs[index]
+                @env[:ui].info("#{index + 1}) #{interface[:name]}", :prefix => false)
+              end
+
+              # The range of valid choices
+              valid = Range.new(1, bridgedifs.length)
+
+              # The choice that the user has chosen as the bridging interface
+              choice = nil
+              while !valid.include?(choice)
+                choice = @env[:ui].ask("What interface should the network bridge to? ")
+                choice = choice.to_i
+              end
+
+              chosen_bridge = bridgedifs[choice - 1][:name]
+            end
+          end
+
+          @logger.info("Bridging adapter #{config[:adapter]} to #{chosen_bridge}")
+
+          # Given the choice we can now define the adapter we're using
+          return {
+            :adapter     => config[:adapter],
+            :type        => :bridged,
+            :bridge      => chosen_bridge,
+            :mac_address => config[:mac],
+            :nic_type    => config[:nic_type]
+          }
+        end
+
+        def bridged_network_config(config)
+          if config[:ip]
+            options = {
+                :auto_config => true,
+                :mac         => nil,
+                :netmask     => "255.255.255.0",
+                :type        => :static
+            }.merge(config)
+            options[:type] = options[:type].to_sym
+            return options
+          end
+
+          return {
+            :type => :dhcp,
+            :use_dhcp_assigned_default_route => config[:use_dhcp_assigned_default_route]
+          }
+        end
+
+        def hostonly_config(options)
+          options = {
+            :auto_config => true,
+            :mac         => nil,
+            :nic_type    => nil,
+            :netmask     => "255.255.255.0",
+            :type        => :static
+          }.merge(options)
+
+          # Make sure the type is a symbol
+          options[:type] = options[:type].to_sym
+
+          # Default IP is in the 20-bit private network block for DHCP based networks
+          options[:ip] = "172.28.128.1" if options[:type] == :dhcp && !options[:ip]
+
+          # Calculate our network address for the given IP/netmask
+          netaddr  = network_address(options[:ip], options[:netmask])
+
+          # Verify that a host-only network subnet would not collide
+          # with a bridged networking interface.
+          #
+          # If the subnets overlap in any way then the host only network
+          # will not work because the routing tables will force the
+          # traffic onto the real interface rather than the VirtualBox
+          # interface.
+          @env[:machine].provider.driver.read_bridged_interfaces.each do |interface|
+            that_netaddr = network_address(interface[:ip], interface[:netmask])
+            raise Vagrant::Errors::NetworkCollision if \
+              netaddr == that_netaddr && interface[:status] != "Down"
+          end
+
+          # Split the IP address into its components
+          ip_parts = netaddr.split(".").map { |i| i.to_i }
+
+          # Calculate the adapter IP, which we assume is the IP ".1" at
+          # the end usually.
+          adapter_ip    = ip_parts.dup
+          adapter_ip[3] += 1
+          options[:adapter_ip] ||= adapter_ip.join(".")
+
+          dhcp_options = {}
+          if options[:type] == :dhcp
+            # Calculate the DHCP server IP, which is the network address
+            # with the final octet + 2. So "172.28.0.0" turns into "172.28.0.2"
+            dhcp_ip    = ip_parts.dup
+            dhcp_ip[3] += 2
+            dhcp_options[:dhcp_ip] ||= dhcp_ip.join(".")
+
+            # Calculate the lower and upper bound for the DHCP server
+            dhcp_lower    = ip_parts.dup
+            dhcp_lower[3] += 3
+            dhcp_options[:dhcp_lower] ||= dhcp_lower.join(".")
+
+            dhcp_upper    = ip_parts.dup
+            dhcp_upper[3] = 254
+            dhcp_options[:dhcp_upper] ||= dhcp_upper.join(".")
+          end
+
+          return {
+            :adapter_ip  => options[:adapter_ip],
+            :auto_config => options[:auto_config],
+            :ip          => options[:ip],
+            :mac         => options[:mac],
+            :netmask     => options[:netmask],
+            :nic_type    => options[:nic_type],
+            :type        => options[:type]
+          }.merge(dhcp_options)
+        end
+
+        def hostonly_adapter(config)
+          @logger.info("Searching for matching hostonly network: #{config[:ip]}")
+          interface = hostonly_find_matching_network(config)
+
+          if !interface
+            @logger.info("Network not found. Creating if we can.")
+
+            # It is an error if a specific host only network name was specified
+            # but the network wasn't found.
+            if config[:name]
+              raise Vagrant::Errors::NetworkNotFound, :name => config[:name]
+            end
+
+            # Create a new network
+            interface = hostonly_create_network(config)
+            @logger.info("Created network: #{interface[:name]}")
+          end
+
+          if config[:type] == :dhcp
+            # Check that if there is a DHCP server attached on our interface,
+            # then it is identical. Otherwise, we can't set it.
+            if interface[:dhcp]
+              valid = interface[:dhcp][:ip] == config[:dhcp_ip] &&
+                  interface[:dhcp][:lower] == config[:dhcp_lower] &&
+                  interface[:dhcp][:upper] == config[:dhcp_upper]
+
+              raise Errors::NetworkDHCPAlreadyAttached if !valid
+
+              @logger.debug("DHCP server already properly configured")
+            else
+              # Configure the DHCP server for the network.
+              @logger.debug("Creating a DHCP server...")
+              @env[:machine].provider.driver.create_dhcp_server(interface[:name], config)
+            end
+          end
+
+          return {
+            :adapter  => config[:adapter],
+            :hostonly => interface[:name],
+            :mac      => config[:mac],
+            :nic_type => config[:nic_type],
+            :type     => :hostonly
+          }
+        end
+
+        def hostonly_network_config(config)
+          return {
+            :type       => config[:type],
+            :adapter_ip => config[:adapter_ip],
+            :ip         => config[:ip],
+            :netmask    => config[:netmask]
+          }
+        end
+
+        def nat_config(options)
+          return {
+            :auto_config => false
+          }
+        end
+
+        def nat_adapter(config)
+          return {
+            :adapter => config[:adapter],
+            :type    => :nat,
+          }
+        end
+
+        def nat_network_config(config)
+          return {}
+        end
+
+        #-----------------------------------------------------------------
+        # Misc. helpers
+        #-----------------------------------------------------------------
+        # Assigns the actual interface number of a network based on the
+        # enabled NICs on the virtual machine.
+        #
+        # This interface number is used by the guest to configure the
+        # NIC on the guest VM.
+        #
+        # The networks are modified in place by adding an ":interface"
+        # field to each.
+        def assign_interface_numbers(networks, adapters)
+          current = 0
+          adapter_to_interface = {}
+
+          # Make a first pass to assign interface numbers by adapter location
+          vm_adapters = @env[:machine].provider.driver.read_network_interfaces
+          vm_adapters.sort.each do |number, adapter|
+            if adapter[:type] != :none
+              # Not used, so assign the interface number and increment
+              adapter_to_interface[number] = current
+              current += 1
+            end
+          end
+
+          # Make a pass through the adapters to assign the :interface
+          # key to each network configuration.
+          adapters.each_index do |i|
+            adapter = adapters[i]
+            network = networks[i]
+
+            # Figure out the interface number by simple lookup
+            network[:interface] = adapter_to_interface[adapter[:adapter]]
+          end
+        end
+
+        #-----------------------------------------------------------------
+        # Hostonly Helper Functions
+        #-----------------------------------------------------------------
+        # This creates a host only network for the given configuration.
+        def hostonly_create_network(config)
+          @env[:machine].provider.driver.create_host_only_network(
+            :adapter_ip => config[:adapter_ip],
+            :netmask    => config[:netmask]
+          )
+        end
+
+        # This finds a matching host only network for the given configuration.
+        def hostonly_find_matching_network(config)
+          this_netaddr = network_address(config[:ip], config[:netmask])
+
+          @env[:machine].provider.driver.read_host_only_interfaces.each do |interface|
+            return interface if config[:name] && config[:name] == interface[:name]
+            return interface if this_netaddr == \
+              network_address(interface[:ip], interface[:netmask])
+          end
+
+          nil
+        end
+      end
+    end
+  end
+end