vagrant-aws-detiber 0.7.2.pre.2

data/vendor/bundle/ruby/2.3.0/bundler/gems/vagrant-419afb4dcffe/lib/vagrant.rb

@@ -0,0 +1,362 @@
+require "vagrant/shared_helpers"
+
+require "rubygems"
+require "log4r"
+require "vagrant/util"
+
+# 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
+    base_formatter = Log4r::BasicFormatter.new
+    if ENV["VAGRANT_LOG_TIMESTAMP"]
+      base_formatter = Log4r::PatternFormatter.new(
+        pattern: "%d [%5l] %m",
+        date_pattern: "%F %T"
+      )
+    end
+    Log4r::Outputter.stderr.formatter = Vagrant::Util::LoggingFormatter.new(base_formatter)
+    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}")
+global_logger.info("Ruby version: #{RUBY_VERSION}")
+global_logger.info("RubyGems version: #{Gem::VERSION}")
+ENV.each do |k, v|
+  next if k.start_with?("VAGRANT_OLD")
+  global_logger.info("#{k}=#{v.inspect}") if k.start_with?("VAGRANT_")
+end
+
+# We need these components always so instead of an autoload we
+# just require them explicitly here.
+require "vagrant/plugin"
+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 :Host,          'vagrant/host'
+  autoload :Machine,       'vagrant/machine'
+  autoload :MachineIndex,  'vagrant/machine_index'
+  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 }
+    c.register([:"2", :push])         { Plugin::V2::Push }
+    c.register([:"2", :synced_folder]) { Plugin::V2::SyncedFolder }
+  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
+
+  # This checks if a plugin with the given name is available (installed
+  # and enabled). This can be used from the Vagrantfile to easily branch
+  # based on plugin availability.
+  def self.has_plugin?(name, version=nil)
+    return false unless Vagrant.plugins_enabled?
+
+    if !version
+      # We check the plugin names first because those are cheaper to check
+      return true if plugin("2").manager.registered.any? { |p| p.name == name }
+    end
+
+    # Make the requirement object
+    version = Gem::Requirement.new([version]) if version
+
+    # Now check the plugin gem names
+    require "vagrant/plugin/manager"
+    Plugin::Manager.instance.installed_specs.any? do |s|
+      match = s.name == name
+      next match if !version
+      next match && version.satisfied_by?(s.version)
+    end
+  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
+
+  # @deprecated
+  def self.require_plugin(name)
+    puts "Vagrant.require_plugin is deprecated and has no effect any longer."
+    puts "Use `vagrant plugin` commands to manage plugins. This warning will"
+    puts "be removed in the next version of Vagrant."
+  end
+
+  # This allows a Vagrantfile to specify the version of Vagrant that is
+  # required. You can specify a list of requirements which will all be checked
+  # against the running Vagrant version.
+  #
+  # This should be specified at the _top_ of any Vagrantfile.
+  #
+  # Examples are shown below:
+  #
+  #   Vagrant.require_version(">= 1.3.5")
+  #   Vagrant.require_version(">= 1.3.5", "< 1.4.0")
+  #   Vagrant.require_version("~> 1.3.5")
+  #
+  def self.require_version(*requirements)
+    logger = Log4r::Logger.new("vagrant::root")
+    logger.info("Version requirements from Vagrantfile: #{requirements.inspect}")
+
+    req = Gem::Requirement.new(*requirements)
+    if req.satisfied_by?(Gem::Version.new(VERSION))
+      logger.info("  - Version requirements satisfied!")
+      return
+    end
+
+    raise Errors::VagrantVersionBad,
+      requirements: requirements.join(", "),
+      version: VERSION
+  end
+
+  # This allows plugin developers to access the original environment before
+  # Vagrant even ran. This is useful when shelling out, especially to other
+  # Ruby processes.
+  #
+  # @return [Hash]
+  def self.original_env
+    {}.tap do |h|
+      ENV.each do |k,v|
+        if k.start_with?("VAGRANT_OLD_ENV")
+          key = k.sub(/^VAGRANT_OLD_ENV_/, "")
+          if !key.empty?
+            h[key] = v
+          end
+        end
+      end
+    end
+  end
+end
+
+# Default I18n to load the en locale
+I18n.load_path << File.expand_path("templates/locales/en.yml", Vagrant.source_root)
+
+if I18n.config.respond_to?(:enforce_available_locales=)
+  # Make sure only available locales are used. This will be the default in the
+  # future but we need this to silence a deprecation warning from 0.6.9
+  I18n.config.enforce_available_locales = true
+end
+
+if Vagrant.enable_resolv_replace
+  global_logger.info("resolv replacement has been enabled!")
+else
+  global_logger.warn("resolv replacement has not been enabled!")
+end
+
+# Setup the plugin manager and load any defined plugins
+require_relative "vagrant/plugin/manager"
+plugins = Vagrant::Plugin::Manager.instance.installed_plugins
+
+global_logger.info("Plugins:")
+plugins.each do |plugin_name, plugin_info|
+  installed_version = plugin_info["installed_gem_version"]
+  version_constraint = plugin_info["gem_version"]
+  installed_version = 'undefined' if installed_version.to_s.empty?
+  version_constraint = '> 0' if version_constraint.to_s.empty?
+  global_logger.info(
+    "  - #{plugin_name} = [installed: " \
+      "#{installed_version} constraint: " \
+      "#{version_constraint}]"
+  )
+end
+
+if Vagrant.plugins_init?
+  begin
+    Vagrant::Bundler.instance.init!(plugins)
+  rescue Exception => e
+    global_logger.error("Plugin initialization error - #{e.class}: #{e}")
+    e.backtrace.each do |backtrace_line|
+      global_logger.debug(backtrace_line)
+    end
+    raise Vagrant::Errors::PluginInitError, message: e.to_s
+  end
+end
+
+# 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
+
+# If we have plugins enabled, then load those
+if Vagrant.plugins_enabled?
+  begin
+    global_logger.info("Loading plugins!")
+    plugins.each do |plugin_name, plugin_info|
+      if plugin_info["require"].to_s.empty?
+        begin
+          global_logger.debug("Loading plugin `#{plugin_name}` with default require: `#{plugin_name}`")
+          require plugin_name
+        rescue LoadError, Gem::LoadError => load_error
+          if plugin_name.include?("-")
+            begin
+              plugin_slash = plugin_name.gsub("-", "/")
+              global_logger.debug("Failed to load plugin `#{plugin_name}` with default require.")
+              global_logger.debug("Loading plugin `#{plugin_name}` with slash require: `#{plugin_slash}`")
+              require plugin_slash
+            rescue LoadError, Gem::LoadError
+              global_logger.warn("Failed to load plugin `#{plugin_name}`. Assuming library and moving on.")
+            end
+          end
+        end
+      else
+        global_logger.debug("Loading plugin `#{plugin_name}` with custom require: `#{plugin_info["require"]}`")
+        require plugin_info["require"]
+      end
+      global_logger.debug("Successfully loaded plugin `#{plugin_name}`.")
+    end
+    if defined?(::Bundler)
+      global_logger.debug("Bundler detected in use. Loading `:plugins` group.")
+      ::Bundler.require(:plugins)
+    end
+  rescue Exception => e
+    global_logger.error("Plugin loading error: #{e.class} - #{e}")
+    e.backtrace.each do |backtrace_line|
+      global_logger.debug(backtrace_line)
+    end
+    raise Vagrant::Errors::PluginLoadError, message: e.to_s
+  end
+else
+  global_logger.debug("Plugin loading is currently disabled.")
+end

data/vendor/bundle/ruby/2.3.0/bundler/gems/vagrant-419afb4dcffe/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/vendor/bundle/ruby/2.3.0/bundler/gems/vagrant-419afb4dcffe/plugins/commands/box/command/add.rb

@@ -0,0 +1,101 @@
+require 'optparse'
+
+require_relative 'download_mixins'
+
+module VagrantPlugins
+  module CommandBox
+    module Command
+      class Add < Vagrant.plugin("2", :command)
+        include DownloadMixins
+
+        def execute
+          options = {}
+
+          opts = OptionParser.new do |o|
+            o.banner = "Usage: vagrant box add [options] <name, url, or path>"
+            o.separator ""
+            o.separator "Options:"
+            o.separator ""
+
+            o.on("-c", "--clean", "Clean any temporary download files") do |c|
+              options[:clean] = c
+            end
+
+            o.on("-f", "--force", "Overwrite an existing box if it exists") do |f|
+              options[:force] = f
+            end
+
+            build_download_options(o, options)
+
+            o.on("--location-trusted", "Trust 'Location' header from HTTP redirects and use the same credentials for subsequent urls as for the initial one") do |l|
+                options[:location_trusted] = l
+            end
+
+            o.on("--provider PROVIDER", String, "Provider the box should satisfy") do |p|
+              options[:provider] = p
+            end
+
+            o.on("--box-version VERSION", String, "Constrain version of the added box") do |v|
+              options[:version] = v
+            end
+
+            o.separator ""
+            o.separator "The box descriptor can be the name of a box on HashiCorp's Vagrant Cloud,"
+            o.separator "or a URL, or a local .box file, or a local .json file containing"
+            o.separator "the catalog metadata."
+            o.separator ""
+            o.separator "The options below only apply if you're adding a box file directly,"
+            o.separator "and not using a Vagrant server or a box structured like 'user/box':"
+            o.separator ""
+
+            o.on("--checksum CHECKSUM", String, "Checksum for the box") do |c|
+              options[:checksum] = c
+            end
+
+            o.on("--checksum-type TYPE", String, "Checksum type (md5, sha1, sha256)") do |c|
+              options[:checksum_type] = c.to_sym
+            end
+
+            o.on("--name BOX", String, "Name of the box") do |n|
+              options[:name] = n
+            end
+          end
+
+          # Parse the options
+          argv = parse_options(opts)
+          return if !argv
+          if argv.empty? || argv.length > 2
+            raise Vagrant::Errors::CLIInvalidUsage,
+              help: opts.help.chomp
+          end
+
+          url = argv[0]
+          if argv.length == 2
+            options[:name] = argv[0]
+            url = argv[1]
+          end
+
+          @env.action_runner.run(Vagrant::Action.action_box_add, {
+            box_url: url,
+            box_name: options[:name],
+            box_provider: options[:provider],
+            box_version: options[:version],
+            box_checksum_type: options[:checksum_type],
+            box_checksum: options[:checksum],
+            box_clean: options[:clean],
+            box_force: options[:force],
+            box_download_ca_cert: options[:ca_cert],
+            box_download_ca_path: options[:ca_path],
+            box_client_cert: options[:client_cert],
+            box_download_insecure: options[:insecure],
+            box_download_location_trusted: options[:location_trusted],
+            ui: Vagrant::UI::Prefixed.new(@env.ui, "box"),
+          })
+
+          # Success, exit status 0
+          0
+        end
+      end
+    end
+  end
+end

data/vendor/bundle/ruby/2.3.0/bundler/gems/vagrant-419afb4dcffe/plugins/commands/box/command/download_mixins.rb

@@ -0,0 +1,29 @@
+module VagrantPlugins
+  module CommandBox
+    module DownloadMixins
+      # This adds common download command line flags to the given
+      # OptionParser, storing the result in the `options` dictionary.
+      #
+      # @param [OptionParser] parser
+      # @param [Hash] options
+      def build_download_options(parser, options)
+        # Add the options
+        parser.on("--insecure", "Do not validate SSL certificates") do |i|
+          options[:insecure] = i
+        end
+
+        parser.on("--cacert FILE", String, "CA certificate for SSL download") do |c|
+          options[:ca_cert] = c
+        end
+
+        parser.on("--capath DIR", String, "CA certificate directory for SSL download") do |c|
+          options[:ca_path] = c
+        end
+
+        parser.on("--cert FILE", String, "A client SSL cert, if needed") do |c|
+          options[:client_cert] = c
+        end
+      end
+    end
+  end
+end

data/vendor/bundle/ruby/2.3.0/bundler/gems/vagrant-419afb4dcffe/plugins/commands/box/command/list.rb

@@ -0,0 +1,71 @@
+require 'optparse'
+
+module VagrantPlugins
+  module CommandBox
+    module Command
+      class List < Vagrant.plugin("2", :command)
+        def execute
+          options = {}
+
+          opts = OptionParser.new do |o|
+            o.banner = "Usage: vagrant box list [options]"
+            o.separator ""
+            o.separator "Options:"
+            o.separator ""
+
+            o.on("-i", "--box-info", "Displays additional information about the boxes") do |i|
+              options[:info] = i
+            end
+          end
+
+          # Parse the options
+          argv = parse_options(opts)
+          return if !argv
+
+          boxes = @env.boxes.all
+          if boxes.empty?
+            return @env.ui.warn(I18n.t("vagrant.commands.box.no_installed_boxes"), prefix: false)
+          end
+
+          list_boxes(boxes, options[:info])
+
+          # Success, exit status 0
+          0
+        end
+
+        private
+
+        def list_boxes(boxes, extra_info)
+          # 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, version, provider|
+            @env.ui.info("#{name.ljust(longest_box_length)} (#{provider}, #{version})")
+
+            @env.ui.machine("box-name", name)
+            @env.ui.machine("box-provider", provider)
+            @env.ui.machine("box-version", version)
+
+            info_file = @env.boxes.find(name, provider, version).
+              directory.join("info.json")
+            if info_file.file?
+              info = JSON.parse(info_file.read)
+              info.each do |k, v|
+                @env.ui.machine("box-info", k, v)
+
+                if extra_info
+                  @env.ui.info("  - #{k}: #{v}", prefix: false)
+                end
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/vendor/bundle/ruby/2.3.0/bundler/gems/vagrant-419afb4dcffe/plugins/commands/box/command/outdated.rb

@@ -0,0 +1,96 @@
+require 'optparse'
+
+require_relative 'download_mixins'
+
+module VagrantPlugins
+  module CommandBox
+    module Command
+      class Outdated < Vagrant.plugin("2", :command)
+        include DownloadMixins
+
+        def execute
+          options = {}
+          download_options = {}
+
+          opts = OptionParser.new do |o|
+            o.banner = "Usage: vagrant box outdated [options]"
+            o.separator ""
+            o.separator "Checks if there is a new version available for the box"
+            o.separator "that are you are using. If you pass in the --global flag,"
+            o.separator "all boxes will be checked for updates."
+            o.separator ""
+            o.separator "Options:"
+            o.separator ""
+
+            o.on("--global", "Check all boxes installed") do |g|
+              options[:global] = g
+            end
+
+            build_download_options(o, download_options)
+          end
+
+          argv = parse_options(opts)
+          return if !argv
+
+          # If we're checking the boxes globally, then do that.
+          if options[:global]
+            outdated_global(download_options)
+            return 0
+          end
+
+          with_target_vms(argv) do |machine|
+            @env.action_runner.run(Vagrant::Action.action_box_outdated, {
+              box_outdated_force: true,
+              box_outdated_refresh: true,
+              box_outdated_success_ui: true,
+              machine: machine,
+            }.merge(download_options))
+          end
+        end
+
+        def outdated_global(download_options)
+          boxes = {}
+          @env.boxes.all.reverse.each do |name, version, provider|
+            box = @env.boxes.find(name, provider, version)
+            if !box.metadata_url
+              @env.ui.output(I18n.t(
+                "vagrant.box_outdated_no_metadata",
+                name: box.name,
+                provider: box.provider))
+              next
+            end
+
+            md = nil
+            begin
+              md = box.load_metadata(download_options)
+            rescue Vagrant::Errors::BoxMetadataDownloadError => e
+              @env.ui.error(I18n.t(
+                "vagrant.box_outdated_metadata_error",
+                name: box.name,
+                provider: box.provider,
+                message: e.extra_data[:message]))
+              next
+            end
+
+            current = Gem::Version.new(box.version)
+            latest  = Gem::Version.new(md.versions.last)
+            if latest <= current
+              @env.ui.success(I18n.t(
+                "vagrant.box_up_to_date",
+                name: box.name,
+                provider: box.provider,
+                version: box.version))
+            else
+              @env.ui.warn(I18n.t(
+                "vagrant.box_outdated",
+                name: box.name,
+                provider: box.provider,
+                current: box.version,
+                latest: latest.to_s,))
+            end
+          end
+        end
+      end
+    end
+  end
+end