tnargav 1.2.2

data/lib/vagrant.rb

@@ -0,0 +1,258 @@
+require 'log4r'
+
+# Enable logging if it is requested. We do this before
+# anything else so that we can setup the output before
+# any logging occurs.
+if ENV["VAGRANT_LOG"] && ENV["VAGRANT_LOG"] != ""
+  # Require Log4r and define the levels we'll be using
+  require 'log4r/config'
+  Log4r.define_levels(*Log4r::Log4rConfig::LogLevels)
+
+  level = nil
+  begin
+    level = Log4r.const_get(ENV["VAGRANT_LOG"].upcase)
+  rescue NameError
+    # This means that the logging constant wasn't found,
+    # which is fine. We just keep `level` as `nil`. But
+    # we tell the user.
+    level = nil
+  end
+
+  # Some constants, such as "true" resolve to booleans, so the
+  # above error checking doesn't catch it. This will check to make
+  # sure that the log level is an integer, as Log4r requires.
+  level = nil if !level.is_a?(Integer)
+
+  if !level
+    # We directly write to stderr here because the VagrantError system
+    # is not setup yet.
+    $stderr.puts "Invalid VAGRANT_LOG level is set: #{ENV["VAGRANT_LOG"]}"
+    $stderr.puts ""
+    $stderr.puts "Please use one of the standard log levels: debug, info, warn, or error"
+    exit 1
+  end
+
+  # Set the logging level on all "vagrant" namespaced
+  # logs as long as we have a valid level.
+  if level
+    logger = Log4r::Logger.new("vagrant")
+    logger.outputters = Log4r::Outputter.stderr
+    logger.level = level
+    logger = nil
+  end
+end
+
+require 'json'
+require 'pathname'
+require 'stringio'
+
+require 'childprocess'
+require 'i18n'
+
+# OpenSSL must be loaded here since when it is loaded via `autoload`
+# there are issues with ciphers not being properly loaded.
+require 'openssl'
+
+# Always make the version available
+require 'vagrant/version'
+global_logger = Log4r::Logger.new("vagrant::global")
+global_logger.info("Vagrant version: #{Vagrant::VERSION}")
+
+# We need these components always so instead of an autoload we
+# just require them explicitly here.
+require "vagrant/registry"
+
+module Vagrant
+  autoload :Action,        'vagrant/action'
+  autoload :BatchAction,   'vagrant/batch_action'
+  autoload :Box,           'vagrant/box'
+  autoload :BoxCollection, 'vagrant/box_collection'
+  autoload :CLI,           'vagrant/cli'
+  autoload :Command,       'vagrant/command'
+  autoload :Config,        'vagrant/config'
+  autoload :Driver,        'vagrant/driver'
+  autoload :Environment,   'vagrant/environment'
+  autoload :Errors,        'vagrant/errors'
+  autoload :Guest,         'vagrant/guest'
+  autoload :Hosts,         'vagrant/hosts'
+  autoload :Machine,       'vagrant/machine'
+  autoload :MachineState,  'vagrant/machine_state'
+  autoload :Plugin,        'vagrant/plugin'
+  autoload :UI,            'vagrant/ui'
+  autoload :Util,          'vagrant/util'
+
+  # These are the various plugin versions and their components in
+  # a lazy loaded Hash-like structure.
+  PLUGIN_COMPONENTS = Registry.new.tap do |c|
+    c.register(:"1")                  { Plugin::V1::Plugin }
+    c.register([:"1", :command])      { Plugin::V1::Command }
+    c.register([:"1", :communicator]) { Plugin::V1::Communicator }
+    c.register([:"1", :config])       { Plugin::V1::Config }
+    c.register([:"1", :guest])        { Plugin::V1::Guest }
+    c.register([:"1", :host])         { Plugin::V1::Host }
+    c.register([:"1", :provider])     { Plugin::V1::Provider }
+    c.register([:"1", :provisioner])  { Plugin::V1::Provisioner }
+
+    c.register(:"2")                  { Plugin::V2::Plugin }
+    c.register([:"2", :command])      { Plugin::V2::Command }
+    c.register([:"2", :communicator]) { Plugin::V2::Communicator }
+    c.register([:"2", :config])       { Plugin::V2::Config }
+    c.register([:"2", :guest])        { Plugin::V2::Guest }
+    c.register([:"2", :host])         { Plugin::V2::Host }
+    c.register([:"2", :provider])     { Plugin::V2::Provider }
+    c.register([:"2", :provisioner])  { Plugin::V2::Provisioner }
+  end
+
+  # This returns a true/false showing whether we're running from the
+  # environment setup by the Vagrant installers.
+  #
+  # @return [Boolean]
+  def self.in_installer?
+    !!ENV["VAGRANT_INSTALLER_ENV"]
+  end
+
+  # The source root is the path to the root directory of
+  # the Vagrant gem.
+  def self.source_root
+    @source_root ||= Pathname.new(File.expand_path('../../', __FILE__))
+  end
+
+  # Configure a Vagrant environment. The version specifies the version
+  # of the configuration that is expected by the block. The block, based
+  # on that version, configures the environment.
+  #
+  # Note that the block isn't run immediately. Instead, the configuration
+  # block is stored until later, and is run when an environment is loaded.
+  #
+  # @param [String] version Version of the configuration
+  def self.configure(version, &block)
+    Config.run(version, &block)
+  end
+
+  # Returns a superclass to use when creating a plugin for Vagrant.
+  # Given a specific version, this returns a proper superclass to use
+  # to register plugins for that version.
+  #
+  # Optionally, if you give a specific component, then it will return
+  # the proper superclass for that component as well.
+  #
+  # Plugins and plugin components should subclass the classes returned by
+  # this method. This method lets Vagrant core control these superclasses
+  # and change them over time without affecting plugins. For example, if
+  # the V1 superclass happens to be "Vagrant::V1," future versions of
+  # Vagrant may move it to "Vagrant::Plugins::V1" and plugins will not be
+  # affected.
+  #
+  # @param [String] version
+  # @param [String] component
+  # @return [Class]
+  def self.plugin(version, component=nil)
+    # Build up the key and return a result
+    key    = version.to_s.to_sym
+    key    = [key, component.to_s.to_sym] if component
+    result = PLUGIN_COMPONENTS.get(key)
+
+    # If we found our component then we return that
+    return result if result
+
+    # If we didn't find a result, then raise an exception, depending
+    # on if we got a component or not.
+    raise ArgumentError, "Plugin superclass not found for version/component: " +
+      "#{version} #{component}"
+  end
+
+  # This should be used instead of Ruby's built-in `require` in order to
+  # load a Vagrant plugin. This will load the given plugin by first doing
+  # a normal `require`, giving a nice error message if things go wrong,
+  # and second by verifying that a Vagrant plugin was actually defined in
+  # the process.
+  #
+  # @param [String] name Name of the plugin to load.
+  def self.require_plugin(name)
+    if ENV["VAGRANT_NO_PLUGINS"]
+      logger = Log4r::Logger.new("vagrant::root")
+      logger.warn("VAGRANT_NO_PLUGINS is set, not loading 3rd party plugin: #{name}")
+      return
+    end
+
+    # Redirect stdout/stderr so that we can output it in our own way.
+    previous_stderr = $stderr
+    previous_stdout = $stdout
+    $stderr = StringIO.new
+    $stdout = StringIO.new
+
+    # Attempt the normal require
+    begin
+      require name
+    rescue Exception => e
+      # Since this is a rare case, we create a one-time logger here
+      # in order to output the error
+      logger = Log4r::Logger.new("vagrant::root")
+      logger.error("Failed to load plugin: #{name}")
+      logger.error(" -- Error: #{e.inspect}")
+      logger.error(" -- Backtrace:")
+      logger.error(e.backtrace.join("\n"))
+
+      # If it is a LoadError we first try to see if it failed loading
+      # the top-level entrypoint. If so, then we report a different error.
+      if e.is_a?(LoadError)
+        # Parse the message in order to get what failed to load, and
+        # add some extra protection around if the message is different.
+        parts = e.to_s.split(" -- ", 2)
+        if parts.length == 2 && parts[1] == name
+          raise Errors::PluginLoadError, :plugin => name
+        end
+      end
+
+      # Get the string data out from the stdout/stderr captures
+      stderr = $stderr.string
+      stdout = $stdout.string
+      if !stderr.empty? || !stdout.empty?
+        raise Errors::PluginLoadFailedWithOutput,
+          :plugin => name,
+          :stderr => stderr,
+          :stdout => stdout
+      end
+
+      # And raise an error itself
+      raise Errors::PluginLoadFailed,
+        :plugin => name
+    end
+  ensure
+    $stderr = previous_stderr if previous_stderr
+    $stdout = previous_stdout if previous_stdout
+  end
+end
+
+# Default I18n to load the en locale
+I18n.load_path << File.expand_path("templates/locales/en.yml", Vagrant.source_root)
+
+# A lambda that knows how to load plugins from a single directory.
+plugin_load_proc = lambda do |directory|
+  # We only care about directories
+  next false if !directory.directory?
+
+  # If there is a plugin file in the top-level directory, then load
+  # that up.
+  plugin_file = directory.join("plugin.rb")
+  if plugin_file.file?
+    global_logger.debug("Loading core plugin: #{plugin_file}")
+    load(plugin_file)
+    next true
+  end
+end
+
+# Go through the `plugins` directory and attempt to load any plugins. The
+# plugins are allowed to be in a directory in `plugins` or at most one
+# directory deep within the plugins directory. So a plugin can be at
+# `plugins/foo` or also at `plugins/foo/bar`, but no deeper.
+Vagrant.source_root.join("plugins").children(true).each do |directory|
+  # Ignore non-directories
+  next if !directory.directory?
+
+  # Load from this directory, and exit if we successfully loaded a plugin
+  next if plugin_load_proc.call(directory)
+
+  # Otherwise, attempt to load from sub-directories
+  directory.children(true).each(&plugin_load_proc)
+end

data/plugins/README.md

@@ -0,0 +1,5 @@
+# Vagrant Core Plugins
+
+These are plugins that ship with Vagrant. Vagrant core uses its own
+plugin system to power a lot of the core pieces that ship with Vagrant.
+Each plugin will have its own README which explains its specific role.

data/plugins/commands/box/command/add.rb

@@ -0,0 +1,51 @@
+require 'optparse'
+
+module VagrantPlugins
+  module CommandBox
+    module Command
+      class Add < Vagrant.plugin("2", :command)
+        def execute
+          options = {}
+
+          opts = OptionParser.new do |o|
+            o.banner = "Usage: vagrant box add <name> <url> [--provider provider] [-h]"
+            o.separator ""
+
+            o.on("-f", "--force", "Overwrite an existing box if it exists.") do |f|
+              options[:force] = f
+            end
+
+            o.on("--insecure", "If set, SSL certs will not be validated.") do |i|
+              options[:insecure] = i
+            end
+
+            o.on("--provider provider", String,
+                 "The provider that backs the box.") do |p|
+              options[:provider] = p
+            end
+          end
+
+          # Parse the options
+          argv = parse_options(opts)
+          return if !argv
+          raise Vagrant::Errors::CLIInvalidUsage, :help => opts.help.chomp if argv.length < 2
+
+          # Get the provider if one was set
+          provider = nil
+          provider = options[:provider].to_sym if options[:provider]
+
+          @env.action_runner.run(Vagrant::Action.action_box_add, {
+            :box_name     => argv[0],
+            :box_provider => provider,
+            :box_url      => argv[1],
+            :box_force    => options[:force],
+            :box_download_insecure => options[:insecure],
+          })
+
+          # Success, exit status 0
+          0
+        end
+      end
+    end
+  end
+end

data/plugins/commands/box/command/list.rb

@@ -0,0 +1,41 @@
+require 'optparse'
+
+module VagrantPlugins
+  module CommandBox
+    module Command
+      class List < Vagrant.plugin("2", :command)
+        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.all.sort
+          if boxes.empty?
+            return @env.ui.warn(I18n.t("vagrant.commands.box.no_installed_boxes"), :prefix => false)
+          end
+
+          # Find the longest box name
+          longest_box = boxes.max_by { |x| x[0].length }
+          longest_box_length = longest_box[0].length
+
+          # Go through each box and output the information about it. We
+          # ignore the "v1" param for now since I'm not yet sure if its
+          # important for the user to know what boxes need to be upgraded
+          # and which don't, since we plan on doing that transparently.
+          boxes.each do |name, provider, _v1|
+            @env.ui.info("#{name.ljust(longest_box_length)} (#{provider})", :prefix => false)
+          end
+
+          # Success, exit status 0
+          0
+        end
+      end
+    end
+  end
+end

data/plugins/commands/box/command/remove.rb

@@ -0,0 +1,37 @@
+require 'optparse'
+
+module VagrantPlugins
+  module CommandBox
+    module Command
+      class Remove < Vagrant.plugin("2", :command)
+        def execute
+          opts = OptionParser.new do |o|
+            o.banner = "Usage: vagrant box remove <name> <provider>"
+          end
+
+          # Parse the options
+          argv = parse_options(opts)
+          return if !argv
+          raise Vagrant::Errors::CLIInvalidUsage, :help => opts.help.chomp if argv.length < 2
+
+          b = nil
+          begin
+            b = @env.boxes.find(argv[0], argv[1].to_sym)
+          rescue Vagrant::Errors::BoxUpgradeRequired
+            @env.boxes.upgrade(argv[0])
+            retry
+          end
+
+          raise Vagrant::Errors::BoxNotFound, :name => argv[0] if !b
+          @env.ui.info(I18n.t("vagrant.commands.box.removing",
+                              :name => argv[0],
+                              :provider => argv[1]))
+          b.destroy!
+
+          # Success, exit status 0
+          0
+        end
+      end
+    end
+  end
+end

data/plugins/commands/box/command/repackage.rb

@@ -0,0 +1,43 @@
+require "fileutils"
+require 'optparse'
+require "pathname"
+
+module VagrantPlugins
+  module CommandBox
+    module Command
+      class Repackage < Vagrant.plugin("2", :command)
+        def execute
+          opts = OptionParser.new do |o|
+            o.banner = "Usage: vagrant box repackage <name> <provider>"
+          end
+
+          # Parse the options
+          argv = parse_options(opts)
+          return if !argv
+          raise Vagrant::Errors::CLIInvalidUsage, :help => opts.help.chomp if argv.length < 2
+
+          box_name     = argv[0]
+          box_provider = argv[1].to_sym
+
+          # Verify the box exists that we want to repackage
+          box = nil
+          begin
+            box = @env.boxes.find(box_name, box_provider)
+          rescue Vagrant::Errors::BoxUpgradeRequired
+            @env.boxes.upgrade(box_name)
+            retry
+          end
+
+          raise Vagrant::Errors::BoxNotFound, :name => box_name if !box
+
+          # Repackage the box
+          output_path = Pathname.new(File.expand_path(@env.config_global.package.name, FileUtils.pwd))
+          box.repackage(output_path)
+
+          # Success, exit status 0
+          0
+        end
+      end
+    end
+  end
+end

data/plugins/commands/box/command/root.rb

@@ -0,0 +1,75 @@
+require 'optparse'
+
+module VagrantPlugins
+  module CommandBox
+    module Command
+      class Root < Vagrant.plugin("2", :command)
+        def initialize(argv, env)
+          super
+
+          @main_args, @sub_command, @sub_args = split_main_and_subcommand(argv)
+
+          @subcommands = Vagrant::Registry.new
+          @subcommands.register(:add) do
+            require File.expand_path("../add", __FILE__)
+            Add
+          end
+
+          @subcommands.register(:list) do
+            require File.expand_path("../list", __FILE__)
+            List
+          end
+
+          @subcommands.register(:remove) do
+            require File.expand_path("../remove", __FILE__)
+            Remove
+          end
+
+          @subcommands.register(:repackage) do
+            require File.expand_path("../repackage", __FILE__)
+            Repackage
+          end
+        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
+end

data/plugins/commands/box/plugin.rb

@@ -0,0 +1,15 @@
+require "vagrant"
+
+module VagrantPlugins
+  module CommandBox
+    class Plugin < Vagrant.plugin("2")
+      name "box command"
+      description "The `box` command gives you a way to manage boxes."
+
+      command("box") do
+        require File.expand_path("../command/root", __FILE__)
+        Command::Root
+      end
+    end
+  end
+end

data/plugins/commands/destroy/command.rb

@@ -0,0 +1,31 @@
+module VagrantPlugins
+  module CommandDestroy
+    class Command < Vagrant.plugin("2", :command)
+      def execute
+        options = {}
+        options[:force] = false
+
+        opts = OptionParser.new do |o|
+          o.banner = "Usage: vagrant destroy [vm-name]"
+          o.separator ""
+
+          o.on("-f", "--force", "Destroy without confirmation.") do |f|
+            options[:force] = f
+          end
+        end
+
+        # Parse the options
+        argv = parse_options(opts)
+        return if !argv
+
+        @logger.debug("'Destroy' each target VM...")
+        with_target_vms(argv, :reverse => true) do |vm|
+          vm.action(:destroy, :force_confirm_destroy => options[:force])
+        end
+
+        # Success, exit status 0
+        0
+      end
+    end
+  end
+end

data/plugins/commands/destroy/plugin.rb

@@ -0,0 +1,18 @@
+require "vagrant"
+
+module VagrantPlugins
+  module CommandDestroy
+    class Plugin < Vagrant.plugin("2")
+      name "destroy command"
+      description <<-DESC
+      The `destroy` command deletes and removes the files and record of your virtual machines.
+      All data is lost and a new VM will have to be created using `up`
+      DESC
+
+      command("destroy") do
+        require File.expand_path("../command", __FILE__)
+        Command
+      end
+    end
+  end
+end

data/plugins/commands/halt/command.rb

@@ -0,0 +1,33 @@
+require 'optparse'
+
+module VagrantPlugins
+  module CommandHalt
+    class Command < Vagrant.plugin("2", :command)
+      def execute
+        options = {}
+        options[:force] = false
+
+        opts = OptionParser.new do |o|
+          o.banner = "Usage: vagrant halt [vm-name] [--force] [-h]"
+          o.separator ""
+
+          o.on("-f", "--force", "Force shut down (equivalent of pulling power)") do |f|
+            options[:force] = f
+          end
+        end
+
+        # Parse the options
+        argv = parse_options(opts)
+        return if !argv
+
+        @logger.debug("Halt command: #{argv.inspect} #{options.inspect}")
+        with_target_vms(argv) do |vm|
+          vm.action(:halt, :force_halt => options[:force])
+        end
+
+        # Success, exit status 0
+        0
+      end
+    end
+  end
+end

data/plugins/commands/halt/plugin.rb

@@ -0,0 +1,18 @@
+require "vagrant"
+
+module VagrantPlugins
+  module CommandHalt
+    class Plugin < Vagrant.plugin("2")
+      name "halt command"
+      description <<-DESC
+      The `halt` command shuts your virtual machine down forcefully.
+      The command `up` recreates it.
+      DESC
+
+      command("halt") do
+        require File.expand_path("../command", __FILE__)
+        Command
+      end
+    end
+  end
+end

data/plugins/commands/init/command.rb

@@ -0,0 +1,40 @@
+require 'optparse'
+
+require 'vagrant/util/template_renderer'
+
+module VagrantPlugins
+  module CommandInit
+    class Command < Vagrant.plugin("2", :command)
+      def execute
+        options = {}
+
+        opts = OptionParser.new do |opts|
+          opts.banner = "Usage: vagrant init [box-name] [box-url]"
+        end
+
+        # Parse the options
+        argv = parse_options(opts)
+        return if !argv
+
+        save_path = @env.cwd.join("Vagrantfile")
+        raise Vagrant::Errors::VagrantfileExistsError if save_path.exist?
+
+        template_path = ::Vagrant.source_root.join("templates/commands/init/Vagrantfile")
+        contents = Vagrant::Util::TemplateRenderer.render(template_path,
+                                                          :box_name => argv[0] || "base",
+                                                          :box_url => argv[1])
+
+        # Write out the contents
+        save_path.open("w+") do |f|
+          f.write(contents)
+        end
+
+        @env.ui.info(I18n.t("vagrant.commands.init.success"),
+                     :prefix => false)
+
+        # Success, exit status 0
+        0
+       end
+    end
+  end
+end