vagrant 1.0.7 → 2.4.4

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

@@ -1,61 +0,0 @@
-require "log4r"
-
-module Vagrant
-  module Action
-    module VM
-      class Provision
-        def initialize(app, env)
-          @logger = Log4r::Logger.new("vagrant::action::vm::provision")
-          @app = app
-
-          env["provision.enabled"] = true if !env.has_key?("provision.enabled")
-        end
-
-        def call(env)
-          @env = env
-
-          provisioners = nil
-
-          # We set this here so that even if this value is changed in the future,
-          # it stays constant to what we expect here in this moment.
-          enabled = env["provision.enabled"]
-          # Instantiate and prepare the provisioners. Preparation must happen here
-          # so that shared folders and such can properly take effect.
-          provisioners = enabled_provisioners
-          provisioners.map { |p| p.prepare }
-
-          @app.call(env)
-
-          if enabled
-            # Take prepared provisioners and run the provisioning
-            provisioners.each do |instance|
-              @env[:ui].info I18n.t("vagrant.actions.vm.provision.beginning",
-                                    :provisioner => instance.class)
-              instance.provision!
-            end
-          end
-        end
-
-        def enabled_provisioners
-          enabled = []
-          @env[:vm].config.vm.provisioners.each do |provisioner|
-            if @env["provision.types"]
-              # If we've specified types of provisioners to enable, then we
-              # only use those provisioners, and skip any that we haven't
-              # specified.
-              if !@env["provision.types"].include?(provisioner.shortcut.to_s)
-                @logger.debug("Skipping provisioner: #{provisioner.shortcut}")
-                next
-              end
-            end
-
-            enabled << provisioner.provisioner.new(@env, provisioner.config)
-          end
-
-          # Return the enable provisioners
-          enabled
-        end
-      end
-    end
-  end
-end

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

@@ -1,26 +0,0 @@
-module Vagrant
-  module Action
-    module VM
-      class ProvisionerCleanup
-        def initialize(app, env)
-          @app = app
-          @env = env
-        end
-
-        def call(env)
-          enabled_provisioners.each do |instance|
-            instance.cleanup
-          end
-
-          @app.call(env)
-        end
-
-        def enabled_provisioners
-          @env[:vm].config.vm.provisioners.map do |provisioner|
-            provisioner.provisioner.new(@env, provisioner.config)
-          end
-        end
-      end
-    end
-  end
-end

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

@@ -1,20 +0,0 @@
-module Vagrant
-  module Action
-    module VM
-      class PruneNFSExports
-        def initialize(app, env)
-          @app = app
-        end
-
-        def call(env)
-          if env[:host]
-            valid_ids = env[:vm].driver.read_vms
-            env[:host].nfs_prune(valid_ids)
-          end
-
-          @app.call(env)
-        end
-      end
-    end
-  end
-end

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

@@ -1,20 +0,0 @@
-module Vagrant
-  module Action
-    module VM
-      class Resume
-        def initialize(app, env)
-          @app = app
-        end
-
-        def call(env)
-          if env[:vm].state == :saved
-            env[:ui].info I18n.t("vagrant.actions.vm.resume.resuming")
-            env[:action_runner].run(Boot, env)
-          end
-
-          @app.call(env)
-        end
-      end
-    end
-  end
-end

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

@@ -1,78 +0,0 @@
-require "log4r"
-
-module Vagrant
-  module Action
-    module VM
-      # This middleware enforces some sane defaults on the virtualbox
-      # VM which help with performance, stability, and in some cases
-      # behavior.
-      class SaneDefaults
-        def initialize(app, env)
-          @logger = Log4r::Logger.new("vagrant::action::vm::sanedefaults")
-          @app = app
-        end
-
-        def call(env)
-          # Set the env on an instance variable so we can access it in
-          # helpers.
-          @env = env
-
-          # Enable the host IO cache on the sata controller. Note that
-          # if this fails then its not a big deal, so we don't raise any
-          # errors. The Host IO cache vastly improves disk IO performance
-          # for VMs.
-          command = [
-            "storagectl", env[:vm].uuid,
-            "--name", "SATA Controller",
-            "--hostiocache", "on"
-          ]
-          attempt_and_log(command, "Enabling the Host I/O cache on the SATA controller...")
-
-          enable_dns_proxy = true
-          begin
-            contents = File.read("/etc/resolv.conf")
-
-            if contents =~ /^nameserver 127\.0\.(0|1)\.1$/
-              # The use of both natdnsproxy and natdnshostresolver break on
-              # Ubuntu 12.04 that uses resolvconf with localhost. When used
-              # VirtualBox will give the client dns server 10.0.2.3, while
-              # not binding to that address itself. Therefore disable this
-              # feature if host uses the resolvconf server 127.0.0.1
-              @logger.info("Disabling DNS proxy since resolv.conf contains 127.0.0.1")
-              enable_dns_proxy = false
-            end
-          rescue Errno::ENOENT; end
-
-          # Enable/disable the NAT DNS proxy as necessary
-          if enable_dns_proxy
-            command = [
-              "modifyvm", env[:vm].uuid,
-              "--natdnsproxy1", "on"
-            ]
-            attempt_and_log(command, "Enable the NAT DNS proxy on adapter 1...")
-          else
-            command = [ "modifyvm", env[:vm].uuid, "--natdnsproxy1", "off" ]
-            attempt_and_log(command, "Disable the NAT DNS proxy on adapter 1...")
-            command = [ "modifyvm", env[:vm].uuid, "--natdnshostresolver1", "off" ]
-            attempt_and_log(command, "Disable the NAT DNS resolver on adapter 1...")
-          end
-
-          @app.call(env)
-        end
-
-        protected
-
-        # This is just a helper method that executes a single command, logs
-        # the given string to the log, and also includes the exit status in
-        # the log message.
-        #
-        # @param [Array] command Command to run
-        # @param [String] log Log message to write.
-        def attempt_and_log(command, log)
-          result = @env[:vm].driver.execute_command(command)
-          @logger.info("#{log} (exit status = #{result.exit_code})")
-        end
-      end
-    end
-  end
-end

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

@@ -1,54 +0,0 @@
-require 'pathname'
-
-module Vagrant
-  module Action
-    module VM
-      # Sets up the mapping of files to copy into the package and verifies
-      # that the files can be properly copied.
-      class SetupPackageFiles
-        def initialize(app, env)
-          @app = app
-
-          env["package.include"] ||= []
-          env["package.vagrantfile"] ||= nil
-        end
-
-        def call(env)
-          files = {}
-          env["package.include"].each do |file|
-            source = Pathname.new(file)
-            dest   = nil
-
-            # If the source is relative then we add the file as-is to the include
-            # directory. Otherwise, we copy only the file into the root of the
-            # include directory. Kind of strange, but seems to match what people
-            # expect based on history.
-            if source.relative?
-              dest = source
-            else
-              dest = source.basename
-            end
-
-            # Assign the mapping
-            files[file] = dest
-          end
-
-          if env["package.vagrantfile"]
-            # Vagrantfiles are treated special and mapped to a specific file
-            files[env["package.vagrantfile"]] = "_Vagrantfile"
-          end
-
-          # Verify the mapping
-          files.each do |from, _|
-            raise Errors::PackageIncludeMissing, :file => from if !File.exist?(from)
-          end
-
-          # Save the mapping
-          env["package.files"] = files
-
-          @app.call(env)
-        end
-      end
-    end
-  end
-end

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

@@ -1,114 +0,0 @@
-require 'pathname'
-
-require 'log4r'
-
-module Vagrant
-  module Action
-    module VM
-      class ShareFolders
-        def initialize(app, env)
-          @logger = Log4r::Logger.new("vagrant::action::vm::share_folders")
-          @app    = app
-        end
-
-        def call(env)
-          @env = env
-
-          prepare_folders
-          create_metadata
-
-          @app.call(env)
-
-          mount_shared_folders
-        end
-
-        # This method returns an actual list of VirtualBox shared
-        # folders to create and their proper path.
-        def shared_folders
-          @env[:vm].config.vm.shared_folders.inject({}) do |acc, data|
-            key, value = data
-
-            next acc if value[:disabled]
-
-            # This to prevent overwriting the actual shared folders data
-            value = value.dup
-            acc[key] = value
-            acc
-          end
-        end
-
-        # Prepares the shared folders by verifying they exist and creating them
-        # if they don't.
-        def prepare_folders
-          shared_folders.each do |name, options|
-            hostpath = Pathname.new(options[:hostpath]).expand_path(@env[:root_path])
-
-            if !hostpath.directory? && options[:create]
-              # Host path doesn't exist, so let's create it.
-              @logger.debug("Host path doesn't exist, creating: #{hostpath}")
-
-              begin
-                hostpath.mkpath
-              rescue Errno::EACCES
-                raise Errors::SharedFolderCreateFailed, :path => hostpath.to_s
-              end
-            end
-          end
-        end
-
-        def create_metadata
-          @env[:ui].info I18n.t("vagrant.actions.vm.share_folders.creating")
-
-          folders = []
-          shared_folders.each do |name, data|
-            folders << {
-              :name => name,
-              :hostpath => File.expand_path(data[:hostpath], @env[:root_path]),
-              :transient => data[:transient]
-            }
-          end
-
-          @env[:vm].driver.share_folders(folders)
-        end
-
-        def mount_shared_folders
-          @env[:ui].info I18n.t("vagrant.actions.vm.share_folders.mounting")
-
-          # short guestpaths first, so we don't step on ourselves
-          folders = shared_folders.sort_by do |name, data|
-            if data[:guestpath]
-              data[:guestpath].length
-            else
-              # A long enough path to just do this at the end.
-              10000
-            end
-          end
-
-          # Go through each folder and mount
-          folders.each do |name, data|
-            if data[:guestpath]
-              # Guest path specified, so mount the folder to specified point
-              @env[:ui].info(I18n.t("vagrant.actions.vm.share_folders.mounting_entry",
-                                    :name => name,
-                                    :guest_path => data[:guestpath]))
-
-              # Dup the data so we can pass it to the guest API
-              data = data.dup
-
-              # Calculate the owner and group
-              data[:owner] ||= @env[:vm].config.ssh.username
-              data[:group] ||= @env[:vm].config.ssh.username
-
-              # Mount the actual folder
-              @env[:vm].guest.mount_shared_folder(name, data[:guestpath], data)
-            else
-              # If no guest path is specified, then automounting is disabled
-              @env[:ui].info(I18n.t("vagrant.actions.vm.share_folders.nomount_entry",
-                                    :name => name))
-            end
-          end
-        end
-      end
-    end
-  end
-end

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

@@ -1,20 +0,0 @@
-module Vagrant
-  module Action
-    module VM
-      class Suspend
-        def initialize(app, env)
-          @app = app
-        end
-
-        def call(env)
-          if env[:vm].state == :running
-            env[:ui].info I18n.t("vagrant.actions.vm.suspend.suspending")
-            env[:vm].driver.suspend
-          end
-
-          @app.call(env)
-        end
-      end
-    end
-  end
-end

data/lib/vagrant/command/base.rb

@@ -1,167 +0,0 @@
-require 'log4r'
-
-require "vagrant/util/safe_puts"
-
-module Vagrant
-  module Command
-    # Base class for any CLI commands.
-    #
-    # This class provides documentation on the interface as well as helper
-    # functions that a command has.
-    class Base
-      include Util::SafePuts
-
-      def initialize(argv, env)
-        @argv = argv
-        @env  = env
-        @logger = Log4r::Logger.new("vagrant::command::#{self.class.to_s.downcase}")
-      end
-
-      # This is what is called on the class to actually execute it. Any
-      # subclasses should implement this method and do any option parsing
-      # and validation here.
-      def execute; end
-
-      protected
-
-      # Parses the options given an OptionParser instance.
-      #
-      # This is a convenience method that properly handles duping the
-      # originally argv array so that it is not destroyed.
-      #
-      # This method will also automatically detect "-h" and "--help"
-      # and print help. And if any invalid options are detected, the help
-      # will be printed, as well.
-      #
-      # If this method returns `nil`, then you should assume that help
-      # was printed and parsing failed.
-      def parse_options(opts=nil)
-        # Creating a shallow copy of the arguments so the OptionParser
-        # doesn't destroy the originals.
-        argv = @argv.dup
-
-        # Default opts to a blank optionparser if none is given
-        opts ||= OptionParser.new
-
-        # Add the help option, which must be on every command.
-        opts.on_tail("-h", "--help", "Print this help") do
-          safe_puts(opts.help)
-          return nil
-        end
-
-        opts.parse!(argv)
-        return argv
-      rescue OptionParser::InvalidOption
-        raise Errors::CLIInvalidOptions, :help => opts.help.chomp
-      end
-
-      # Yields a VM for each target VM for the command.
-      #
-      # This is a convenience method for easily implementing methods that
-      # take a target VM (in the case of multi-VM) or every VM if no
-      # specific VM name is specified.
-      #
-      # @param [String] name The name of the VM. Nil if every VM.
-      # @param [Boolean] single_target If true, then an exception will be
-      #   raised if more than one target is found.
-      def with_target_vms(names=nil, options=nil)
-        # Using VMs requires a Vagrant environment to be properly setup
-        raise Errors::NoEnvironmentError if !@env.root_path
-
-        # Setup the options hash
-        options ||= {}
-
-        # Require that names be an array
-        names ||= []
-        names = [names] if !names.is_a?(Array)
-
-        # First determine the proper array of VMs.
-        vms = []
-        if names.length > 0
-          names.each do |name|
-            raise Errors::MultiVMEnvironmentRequired if !@env.multivm?
-
-            if name =~ /^\/(.+?)\/$/
-              # This is a regular expression name, so we convert to a regular
-              # expression and allow that sort of matching.
-              regex = Regexp.new($1.to_s)
-
-              @env.vms.each do |name, vm|
-                vms << vm if name =~ regex
-              end
-
-              raise Errors::VMNoMatchError if vms.empty?
-            else
-              # String name, just look for a specific VM
-              vms << @env.vms[name.to_sym]
-              raise Errors::VMNotFoundError, :name => name if !vms[0]
-            end
-          end
-        else
-          vms = @env.vms_ordered
-        end
-
-        # Make sure we're only working with one VM if single target
-        raise Errors::MultiVMTargetRequired if options[:single_target] && vms.length != 1
-
-        # If we asked for reversed ordering, then reverse it
-        vms.reverse! if options[:reverse]
-
-        # Go through each VM and yield it!
-        vms.each do |old_vm|
-          # We get a new VM from the environment here to avoid potentially
-          # stale VMs (if there was a config reload on the environment
-          # or something).
-          vm = @env.vms[old_vm.name]
-          yield vm
-        end
-      end
-
-      # This method will split the argv given into three parts: the
-      # flags to this command, the subcommand, and the flags to the
-      # subcommand. For example:
-      #
-      #     -v status -h -v
-      #
-      # The above would yield 3 parts:
-      #
-      #     ["-v"]
-      #     "status"
-      #     ["-h", "-v"]
-      #
-      # These parts are useful because the first is a list of arguments
-      # given to the current command, the second is a subcommand, and the
-      # third are the commands given to the subcommand.
-      #
-      # @return [Array] The three parts.
-      def split_main_and_subcommand(argv)
-        # Initialize return variables
-        main_args   = nil
-        sub_command = nil
-        sub_args    = []
-
-        # We split the arguments into two: One set containing any
-        # flags before a word, and then the rest. The rest are what
-        # get actually sent on to the subcommand.
-        argv.each_index do |i|
-          if !argv[i].start_with?("-")
-            # We found the beginning of the sub command. Split the
-            # args up.
-            main_args   = argv[0, i]
-            sub_command = argv[i]
-            sub_args    = argv[i + 1, argv.length - i + 1]
-
-            # Break so we don't find the next non flag and shift our
-            # main args.
-            break
-          end
-        end
-
-        # Handle the case that argv was empty or didn't contain any subcommand
-        main_args = argv.dup if main_args.nil?
-
-        return [main_args, sub_command, sub_args]
-      end
-    end
-  end
-end

data/lib/vagrant/command/box.rb

@@ -1,58 +0,0 @@
-require 'optparse'
-
-module Vagrant
-  module Command
-    class Box < Base
-      def initialize(argv, env)
-        super
-
-        @main_args, @sub_command, @sub_args = split_main_and_subcommand(argv)
-
-        @subcommands = Registry.new
-        @subcommands.register(:add)       { Vagrant::Command::BoxAdd }
-        @subcommands.register(:remove)    { Vagrant::Command::BoxRemove }
-        @subcommands.register(:repackage) { Vagrant::Command::BoxRepackage }
-        @subcommands.register(:list)      { Vagrant::Command::BoxList }
-      end
-
-      def execute
-        if @main_args.include?("-h") || @main_args.include?("--help")
-          # Print the help for all the box commands.
-          return help
-        end
-
-        # If we reached this far then we must have a subcommand. If not,
-        # then we also just print the help and exit.
-        command_class = @subcommands.get(@sub_command.to_sym) if @sub_command
-        return help if !command_class || !@sub_command
-        @logger.debug("Invoking command class: #{command_class} #{@sub_args.inspect}")
-
-        # Initialize and execute the command class
-        command_class.new(@sub_args, @env).execute
-      end
-
-      # Prints the help out for this command
-      def help
-        opts = OptionParser.new do |opts|
-          opts.banner = "Usage: vagrant box <command> [<args>]"
-          opts.separator ""
-          opts.separator "Available subcommands:"
-
-          # Add the available subcommands as separators in order to print them
-          # out as well.
-          keys = []
-          @subcommands.each { |key, value| keys << key.to_s }
-
-          keys.sort.each do |key|
-            opts.separator "     #{key}"
-          end
-
-          opts.separator ""
-          opts.separator "For help on any individual command run `vagrant box COMMAND -h`"
-        end
-
-        @env.ui.info(opts.help, :prefix => false)
-      end
-    end
-  end
-end

data/lib/vagrant/command/box_add.rb

@@ -1,37 +0,0 @@
-require 'optparse'
-
-module Vagrant
-  module Command
-    class BoxAdd < Base
-      def execute
-        options = {}
-
-        opts = OptionParser.new do |opts|
-          opts.banner = "Usage: vagrant box add <name> <url>"
-          opts.separator ""
-
-          opts.on("-f", "--force", "Overwrite an existing box if it exists.") do |f|
-            options[:force] = f
-          end
-        end
-
-        # Parse the options
-        argv = parse_options(opts)
-        return if !argv
-        raise Errors::CLIInvalidUsage, :help => opts.help.chomp if argv.length < 2
-
-        # If we're force adding, then be sure to destroy any existing box if it
-        # exists.
-        if options[:force]
-          existing = @env.boxes.find(argv[0])
-          existing.destroy if existing
-        end
-
-        @env.boxes.add(argv[0], argv[1])
-
-        # Success, exit status 0
-        0
-      end
-    end
-  end
-end

data/lib/vagrant/command/box_list.rb

@@ -1,28 +0,0 @@
-require 'optparse'
-
-module Vagrant
-  module Command
-    class BoxList < Base
-      def execute
-        options = {}
-
-        opts = OptionParser.new do |opts|
-          opts.banner = "Usage: vagrant box list"
-        end
-
-        # Parse the options
-        argv = parse_options(opts)
-        return if !argv
-
-        boxes = @env.boxes.sort
-        if boxes.empty?
-          return @env.ui.warn(I18n.t("vagrant.commands.box.no_installed_boxes"), :prefix => false)
-        end
-        boxes.each { |b| @env.ui.info(b.name, :prefix => false) }
-
-        # Success, exit status 0
-        0
-       end
-    end
-  end
-end