vagrant 1.0.7 → 1.5.0

data/lib/vagrant/action/general/package.rb

@@ -1,101 +0,0 @@
-require 'fileutils'
-require 'archive/tar/minitar'
-
-module Vagrant
-  module Action
-    module General
-      # A general packaging (tar) middleware. Given the following options,
-      # it will do the right thing:
-      #
-      #   * package.output - The filename of the outputted package.
-      #   * package.include - An array of files to include in the package.
-      #   * package.directory - The directory which contains the contents to
-      #       compress into the package.
-      #
-      # This middleware always produces the final file in the current working
-      # directory (FileUtils.pwd)
-      class Package
-        include Util
-
-        def initialize(app, env)
-          @app = app
-
-          env["package.files"]  ||= {}
-          env["package.output"] ||= env["global_config"].package.name
-        end
-
-        def call(env)
-          @env = env
-
-          raise Errors::PackageOutputDirectory if File.directory?(tar_path)
-          raise Errors::PackageOutputExists if File.exist?(tar_path)
-          raise Errors::PackageRequiresDirectory if !env["package.directory"] ||
-            !File.directory?(env["package.directory"])
-
-          compress
-
-          @app.call(env)
-        end
-
-        def recover(env)
-          # There are certain exceptions that we don't delete the file for.
-          ignore_exc = [Errors::PackageOutputDirectory, Errors::PackageOutputExists]
-          ignore_exc.each do |exc|
-            return if env["vagrant.error"].is_a?(exc)
-          end
-
-          # Cleanup any packaged files if the packaging failed at some point.
-          File.delete(tar_path) if File.exist?(tar_path)
-        end
-
-        # This method copies the include files (passed in via command line)
-        # to the temporary directory so they are included in a sub-folder within
-        # the actual box
-        def copy_include_files
-          include_directory = Pathname.new(@env["package.directory"]).join("include")
-
-          @env["package.files"].each do |from, dest|
-            # We place the file in the include directory
-            to = include_directory.join(dest)
-
-            @env[:ui].info I18n.t("vagrant.actions.general.package.packaging", :file => from)
-            FileUtils.mkdir_p(to.parent)
-
-            # Copy direcotry contents recursively.
-            if File.directory?(from)
-              FileUtils.cp_r(Dir.glob(from), to.parent)
-            else
-              FileUtils.cp(from, to)
-            end
-          end
-        end
-
-        # Compress the exported file into a package
-        def compress
-          @env[:ui].info I18n.t("vagrant.actions.general.package.compressing", :tar_path => tar_path)
-          File.open(tar_path, Platform.tar_file_options) do |tar|
-            Archive::Tar::Minitar::Output.open(tar) do |output|
-              begin
-                current_dir = FileUtils.pwd
-
-                copy_include_files
-
-                FileUtils.cd(@env["package.directory"])
-                Dir.glob(File.join(".", "**", "*")).each do |entry|
-                  Archive::Tar::Minitar.pack_file(entry, output)
-                end
-              ensure
-                FileUtils.cd(current_dir)
-              end
-            end
-          end
-        end
-
-        # Path to the final box output file
-        def tar_path
-          File.expand_path(@env["package.output"], FileUtils.pwd)
-        end
-      end
-    end
-  end
-end

data/lib/vagrant/action/general/validate.rb

@@ -1,18 +0,0 @@
-module Vagrant
-  module Action
-    module General
-      # Simply validates the configuration of the current Vagrant
-      # environment.
-      class Validate
-        def initialize(app, env)
-          @app = app
-        end
-
-        def call(env)
-          env[:vm].config.validate!(env[:vm].env) if !env.has_key?("validate") || env["validate"]
-          @app.call(env)
-        end
-      end
-    end
-  end
-end

data/lib/vagrant/action/runner.rb

@@ -1,53 +0,0 @@
-require 'log4r'
-
-require 'vagrant/util/busy'
-
-# TODO:
-# * env.lock
-
-module Vagrant
-  module Action
-    class Runner
-      @@reported_interrupt = false
-
-      def initialize(registry, globals=nil, &block)
-        @registry     = registry
-        @globals      = globals || {}
-        @lazy_globals = block
-        @logger       = Log4r::Logger.new("vagrant::action::runner")
-      end
-
-      def run(callable_id, options=nil)
-        callable = callable_id
-        callable = Builder.new.use(callable_id) if callable_id.kind_of?(Class)
-        callable = @registry.get(callable_id) if callable_id.kind_of?(Symbol)
-        raise ArgumentError, "Argument to run must be a callable object or registered action." if !callable || !callable.respond_to?(:call)
-
-        # Create the initial environment with the options given
-        environment = Environment.new
-        environment.merge!(@globals)
-        environment.merge!(@lazy_globals.call) if @lazy_globals
-        environment.merge!(options || {})
-
-        # Run the action chain in a busy block, marking the environment as
-        # interrupted if a SIGINT occurs, and exiting cleanly once the
-        # chain has been run.
-        ui = environment[:ui] if environment.has_key?(:ui)
-        int_callback = lambda do
-          if environment[:interrupted]
-            ui.error I18n.t("vagrant.actions.runner.exit_immediately") if ui
-            abort
-          end
-
-          ui.warn I18n.t("vagrant.actions.runner.waiting_cleanup") if ui && !@@reported_interrupt
-          environment[:interrupted] = true
-          @@reported_interrupt = true
-        end
-
-        # We place a process lock around every action that is called
-        @logger.info("Running action: #{callable_id}")
-        Util::Busy.busy(int_callback) { callable.call(environment) }
-      end
-    end
-  end
-end

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

@@ -1,53 +0,0 @@
-module Vagrant
-  module Action
-    module VM
-      class Boot
-        def initialize(app, env)
-          @app = app
-          @env = env
-        end
-
-        def call(env)
-          @env = env
-
-          # Start up the VM and wait for it to boot.
-          boot
-          raise Errors::VMFailedToBoot if !wait_for_boot
-
-          @app.call(env)
-        end
-
-        def boot
-          @env[:ui].info I18n.t("vagrant.actions.vm.boot.booting")
-          @env[:vm].driver.start(@env[:vm].config.vm.boot_mode)
-        end
-
-        def wait_for_boot
-          @env[:ui].info I18n.t("vagrant.actions.vm.boot.waiting")
-
-          @env[:vm].config.ssh.max_tries.to_i.times do |i|
-            if @env[:vm].channel.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[:vm].state
-            raise 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/lib/vagrant/action/vm/check_accessible.rb

@@ -1,23 +0,0 @@
-module Vagrant
-  module Action
-    module VM
-      class CheckAccessible
-        def initialize(app, env)
-          @app = app
-        end
-
-        def call(env)
-          if env[:vm].state == :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 Errors::VMInaccessible
-          end
-
-          @app.call(env)
-        end
-      end
-    end
-  end
-end

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

@@ -1,33 +0,0 @@
-module Vagrant
-  module Action
-    module VM
-      class CheckBox
-        def initialize(app, env)
-          @app = app
-        end
-
-        def call(env)
-          box_name = env[:vm].config.vm.box
-          raise Errors::BoxNotSpecified if !box_name
-
-          if !env[:box_collection].find(box_name)
-            box_url = env[:vm].config.vm.box_url
-            raise Errors::BoxSpecifiedDoesntExist, :name => box_name if !box_url
-
-            # Add the box then reload the box collection so that it becomes
-            # aware of it.
-            env[:ui].info I18n.t("vagrant.actions.vm.check_box.not_found", :name => box_name)
-            env[:box_collection].add(box_name, box_url)
-            env[:box_collection].reload!
-
-            # Reload the environment and set the VM to be the new loaded VM.
-            env[:vm].env.reload!
-            env[:vm] = env[:vm].env.vms[env[:vm].name]
-          end
-
-          @app.call(env)
-        end
-      end
-    end
-  end
-end

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

@@ -1,38 +0,0 @@
-module Vagrant
-  module Action
-    module VM
-      # Middleware which verifies that the VM has the proper guest additions
-      # installed and prints a warning if they're not detected or if the
-      # version does not match the installed VirtualBox version.
-      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[:vm].driver.read_guest_additions_version
-          if !version
-            env[:ui].warn I18n.t("vagrant.actions.vm.check_guest_additions.not_detected")
-          else
-            # Strip the -OSE/_OSE off from the guest additions and the virtual box
-            # version since all the matters are that the version _numbers_ match up.
-            guest_version, vb_version = [version, env[:vm].driver.version].map do |v|
-              v.gsub(/[-_]ose/i, '')
-            end
-
-            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/lib/vagrant/action/vm/check_port_collisions.rb

@@ -1,89 +0,0 @@
-require "vagrant/util/is_port_open"
-
-module Vagrant
-  module Action
-    module VM
-      # Action that checks to make sure there are no forwarded port collisions,
-      # and raises an exception if there is.
-      class CheckPortCollisions
-        include Util::IsPortOpen
-
-        def initialize(app, env)
-          @app = app
-        end
-
-        def call(env)
-          # For the handlers...
-          @env = env
-
-          # Figure out how we handle port collisions. By default we error.
-          handler  = env[:port_collision_handler] || :error
-
-          # Read our forwarded ports, if we have any, to override what
-          # we have configured.
-          current = {}
-          env[:vm].driver.read_forwarded_ports.each do |nic, name, hostport, guestport|
-            current[name] = hostport.to_i
-          end
-
-          existing = env[:vm].driver.read_used_ports
-          env[:vm].config.vm.forwarded_ports.each do |options|
-            # Use the proper port, whether that be the configured port or the
-            # port that is currently on use of the VM.
-            hostport = options[:hostport].to_i
-            hostport = current[options[:name]] if current.has_key?(options[:name])
-
-            if existing.include?(hostport) || is_port_open?("127.0.0.1", hostport)
-              # We have a collision! Handle it
-              send("handle_#{handler}".to_sym, options, existing)
-            end
-          end
-
-          @app.call(env)
-        end
-
-        # Handles a port collision by raising an exception.
-        def handle_error(options, existing_ports)
-          raise Errors::ForwardPortCollisionResume
-        end
-
-        # Handles a port collision by attempting to fix it.
-        def handle_correct(options, existing_ports)
-          # We need to keep this for messaging purposes
-          original_hostport = options[:hostport]
-
-          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, :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[:vm].config.vm.auto_port_range.to_a
-          range -= @env[:vm].config.vm.forwarded_ports.collect { |opts| opts[:hostport].to_i }
-          range -= existing_ports
-
-          if range.empty?
-            raise Errors::ForwardPortAutolistEmpty, :vm_name => @env[:vm].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",
-                                :host_port => original_hostport.to_s,
-                                :guest_port => options[:guestport].to_s,
-                                :new_port => options[:hostport]))
-        end
-      end
-    end
-  end
-end

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

@@ -1,43 +0,0 @@
-require 'fileutils'
-
-module Vagrant
-  module Action
-    module VM
-      # 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[:vm].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