vagrant-packet 0.1.2 → 0.1.3

data/vendor/bundle/ruby/2.4.0/bundler/gems/vagrant-04f7215b5e3f/lib/vagrant.rb

@@ -1,362 +0,0 @@
-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")
-Vagrant.global_logger = global_logger
-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 :Alias,         'vagrant/alias'
-  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 StandardError, ScriptError => 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.info("Loading plugin `#{plugin_name}` with default require: `#{plugin_name}`")
-          require plugin_name
-        rescue LoadError => err
-          if plugin_name.include?("-")
-            plugin_slash = plugin_name.gsub("-", "/")
-            global_logger.error("Failed to load plugin `#{plugin_name}` with default require. - #{err.class}: #{err}")
-            global_logger.info("Loading plugin `#{plugin_name}` with slash require: `#{plugin_slash}`")
-            require plugin_slash
-          else
-            raise
-          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 ScriptError, StandardError => err
-    global_logger.error("Plugin loading error: #{err.class} - #{err}")
-    err.backtrace.each do |backtrace_line|
-      global_logger.debug(backtrace_line)
-    end
-    raise Vagrant::Errors::PluginLoadError, message: err.to_s
-  end
-else
-  global_logger.debug("Plugin loading is currently disabled.")
-end

data/vendor/bundle/ruby/2.4.0/bundler/gems/vagrant-04f7215b5e3f/plugins/README.md

@@ -1,5 +0,0 @@
-# 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.4.0/bundler/gems/vagrant-04f7215b5e3f/plugins/commands/box/command/add.rb

@@ -1,101 +0,0 @@
-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.4.0/bundler/gems/vagrant-04f7215b5e3f/plugins/commands/box/command/download_mixins.rb

@@ -1,29 +0,0 @@
-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.4.0/bundler/gems/vagrant-04f7215b5e3f/plugins/commands/box/command/list.rb

@@ -1,71 +0,0 @@
-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.4.0/bundler/gems/vagrant-04f7215b5e3f/plugins/commands/box/command/outdated.rb

@@ -1,96 +0,0 @@
-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