vagrant-packet 0.1.2 → 0.1.3

data/vendor/bundle/ruby/2.4.0/bundler/gems/vagrant-04f7215b5e3f/plugins/commands/login/command.rb

@@ -1,137 +0,0 @@
-require 'socket'
-
-module VagrantPlugins
-  module LoginCommand
-    class Command < Vagrant.plugin("2", "command")
-      def self.synopsis
-        "log in to HashiCorp's Vagrant Cloud"
-      end
-
-      def execute
-        options = {}
-
-        opts = OptionParser.new do |o|
-          o.banner = "Usage: vagrant login"
-          o.separator ""
-          o.on("-c", "--check", "Only checks if you're logged in") do |c|
-            options[:check] = c
-          end
-
-          o.on("-d", "--description DESCRIPTION", String, "Description for the Vagrant Cloud token") do |t|
-            options[:description] = t
-          end
-
-          o.on("-k", "--logout", "Logs you out if you're logged in") do |k|
-            options[:logout] = k
-          end
-
-          o.on("-t", "--token TOKEN", String, "Set the Vagrant Cloud token") do |t|
-            options[:token] = t
-          end
-
-          o.on("-u", "--username USERNAME_OR_EMAIL", String, "Specify your Vagrant Cloud username or email address") do |t|
-            options[:login] = t
-          end
-        end
-
-        # Parse the options
-        argv = parse_options(opts)
-        return if !argv
-
-        @client = Client.new(@env)
-        @client.username_or_email = options[:login]
-
-        # Determine what task we're actually taking based on flags
-        if options[:check]
-          return execute_check
-        elsif options[:logout]
-          return execute_logout
-        elsif options[:token]
-          return execute_token(options[:token])
-        end
-
-        # Let the user know what is going on.
-        @env.ui.output(I18n.t("login_command.command_header") + "\n")
-
-        # If it is a private cloud installation, show that
-        if Vagrant.server_url != Vagrant::DEFAULT_SERVER_URL
-          @env.ui.output("Vagrant Cloud URL: #{Vagrant.server_url}")
-        end
-
-        # Ask for the username
-        if @client.username_or_email
-          @env.ui.output("Vagrant Cloud username or email: #{@client.username_or_email}")
-        end
-        until @client.username_or_email
-          @client.username_or_email = @env.ui.ask("Vagrant Cloud username or email: ")
-        end
-
-        until @client.password
-          @client.password = @env.ui.ask("Password (will be hidden): ", echo: false)
-        end
-
-        description = options[:description]
-        if description
-          @env.ui.output("Token description: #{description}")
-        else
-          description_default = "Vagrant login from #{Socket.gethostname}"
-          until description
-            description =
-              @env.ui.ask("Token description (Defaults to #{description_default.inspect}): ")
-          end
-          description = description_default if description.empty?
-        end
-
-        code = nil
-
-        begin
-          token = @client.login(description: description, code: code)
-        rescue Errors::TwoFactorRequired
-          until code
-            code = @env.ui.ask("2FA code: ")
-
-            if @client.two_factor_delivery_methods.include?(code.downcase)
-              delivery_method, code = code, nil
-              @client.request_code delivery_method
-            end
-          end
-
-          retry
-        end
-
-        @client.store_token(token)
-        @env.ui.success(I18n.t("login_command.logged_in"))
-        0
-      end
-
-      def execute_check
-        if @client.logged_in?
-          @env.ui.success(I18n.t("login_command.check_logged_in"))
-          return 0
-        else
-          @env.ui.error(I18n.t("login_command.check_not_logged_in"))
-          return 1
-        end
-      end
-
-      def execute_logout
-        @client.clear_token
-        @env.ui.success(I18n.t("login_command.logged_out"))
-        return 0
-      end
-
-      def execute_token(token)
-        @client.store_token(token)
-        @env.ui.success(I18n.t("login_command.token_saved"))
-
-        if @client.logged_in?
-          @env.ui.success(I18n.t("login_command.check_logged_in"))
-          return 0
-        else
-          @env.ui.error(I18n.t("login_command.invalid_token"))
-          return 1
-        end
-      end
-    end
-  end
-end

data/vendor/bundle/ruby/2.4.0/bundler/gems/vagrant-04f7215b5e3f/plugins/commands/login/errors.rb

@@ -1,24 +0,0 @@
-module VagrantPlugins
-  module LoginCommand
-    module Errors
-      class Error < Vagrant::Errors::VagrantError
-        error_namespace("login_command.errors")
-      end
-
-      class ServerError < Error
-        error_key(:server_error)
-      end
-
-      class ServerUnreachable < Error
-        error_key(:server_unreachable)
-      end
-
-      class Unauthorized < Error
-        error_key(:unauthorized)
-      end
-
-      class TwoFactorRequired < Error
-      end
-    end
-  end
-end

data/vendor/bundle/ruby/2.4.0/bundler/gems/vagrant-04f7215b5e3f/plugins/commands/login/locales/en.yml

@@ -1,49 +0,0 @@
-en:
-  login_command:
-    middleware:
-      authentication:
-        different_target: |-
-          Vagrant has detected a custom Vagrant server in use for downloading
-          box files. An authentication token is currently set which will be
-          added to the box request. If the custom Vagrant server should not
-          be receiving the authentication token, please unset it.
-
-            Known Vagrant server:  %{known_host}
-            Custom Vagrant server: %{custom_host}
-
-          Press ctrl-c to cancel...
-    errors:
-      server_error: |-
-        The Vagrant Cloud server responded with a not-OK response:
-
-        %{errors}
-      server_unreachable: |-
-        The Vagrant Cloud server is not currently accepting connections. Please check
-        your network connection and try again later.
-
-      unauthorized: |-
-        Invalid username or password. Please try again.
-
-    check_logged_in: |-
-      You are already logged in.
-    check_not_logged_in: |-
-      You are not currently logged in. Please run `vagrant login` and provide
-      your login information to authenticate.
-    command_header: |-
-      In a moment we will ask for your username and password to HashiCorp's
-      Vagrant Cloud. After authenticating, we will store an access token locally on
-      disk. Your login details will be transmitted over a secure connection, and
-      are never stored on disk locally.
-
-      If you do not have an Vagrant Cloud account, sign up at
-      https://www.vagrantcloud.com
-    invalid_login: |-
-      Invalid username or password. Please try again.
-    invalid_token: |-
-      Invalid token. Please try again.
-    logged_in: |-
-      You are now logged in.
-    logged_out: |-
-      You are logged out.
-    token_saved: |-
-      The token was successfully saved.

data/vendor/bundle/ruby/2.4.0/bundler/gems/vagrant-04f7215b5e3f/plugins/commands/login/middleware/add_authentication.rb

@@ -1,83 +0,0 @@
-require "cgi"
-require "uri"
-
-require_relative "../client"
-
-module VagrantPlugins
-  module LoginCommand
-    class AddAuthentication
-      REPLACEMENT_HOSTS = [
-        "app.vagrantup.com".freeze,
-        "atlas.hashicorp.com".freeze
-      ].freeze
-      TARGET_HOST = "vagrantcloud.com".freeze
-      CUSTOM_HOST_NOTIFY_WAIT = 5
-
-      def self.custom_host_notified!
-        @_host_notify = true
-      end
-
-      def self.custom_host_notified?
-        if defined?(@_host_notify)
-          @_host_notify
-        else
-          false
-        end
-      end
-
-      def initialize(app, env)
-        @app = app
-        LoginCommand::Plugin.init!
-      end
-
-      def call(env)
-        client = Client.new(env[:env])
-        token  = client.token
-
-        env[:box_urls].map! do |url|
-          begin
-            u = URI.parse(url)
-            if u.host != TARGET_HOST && REPLACEMENT_HOSTS.include?(u.host)
-              u.host = TARGET_HOST
-              u.to_s
-            else
-              url
-            end
-          rescue URI::Error
-            url
-          end
-        end
-
-        server_uri = URI.parse(Vagrant.server_url.to_s)
-
-        if token && !server_uri.host.to_s.empty?
-          env[:box_urls].map! do |url|
-            u = URI.parse(url)
-
-            if u.host == server_uri.host
-              if server_uri.host != TARGET_HOST && !self.class.custom_host_notified?
-                env[:ui].warn(I18n.t("login_command.middleware.authentication.different_target",
-                  custom_host: server_uri.host, known_host: TARGET_HOST) + "\n")
-                sleep CUSTOM_HOST_NOTIFY_WAIT
-                self.class.custom_host_notified!
-              end
-
-              q = CGI.parse(u.query || "")
-
-              current = q["access_token"]
-              if current && current.empty?
-                q["access_token"] = token
-              end
-
-              u.query = URI.encode_www_form(q)
-            end
-
-            u.to_s
-          end
-        end
-
-        @app.call(env)
-      end.freeze
-    end
-  end
-end

data/vendor/bundle/ruby/2.4.0/bundler/gems/vagrant-04f7215b5e3f/plugins/commands/login/plugin.rb

@@ -1,35 +0,0 @@
-require "vagrant"
-
-module VagrantPlugins
-  module LoginCommand
-    autoload :Client, File.expand_path("../client", __FILE__)
-    autoload :Errors, File.expand_path("../errors", __FILE__)
-
-    class Plugin < Vagrant.plugin("2")
-      name "vagrant-login"
-      description <<-DESC
-      Provides the login command and internal API access to Vagrant Cloud.
-      DESC
-
-      command(:login) do
-        require_relative "command"
-        init!
-        Command
-      end
-
-      action_hook(:cloud_authenticated_boxes, :authenticate_box_url) do |hook|
-        require_relative "middleware/add_authentication"
-        hook.prepend(AddAuthentication)
-      end
-
-      protected
-
-      def self.init!
-        return if defined?(@_init)
-        I18n.load_path << File.expand_path("../locales/en.yml", __FILE__)
-        I18n.reload!
-        @_init = true
-      end
-    end
-  end
-end

data/vendor/bundle/ruby/2.4.0/bundler/gems/vagrant-04f7215b5e3f/plugins/commands/package/command.rb

@@ -1,94 +0,0 @@
-require 'optparse'
-require 'securerandom'
-
-module VagrantPlugins
-  module CommandPackage
-    class Command < Vagrant.plugin("2", :command)
-      def self.synopsis
-        "packages a running vagrant environment into a box"
-      end
-
-      def execute
-        options = {}
-
-        opts = OptionParser.new do |o|
-          o.banner = "Usage: vagrant package [options] [name|id]"
-          o.separator ""
-          o.separator "Options:"
-          o.separator ""
-
-          o.on("--base NAME", "Name of a VM in VirtualBox to package as a base box (VirtualBox Only)") do |b|
-            options[:base] = b
-          end
-
-          o.on("--output NAME", "Name of the file to output") do |output|
-            options[:output] = output
-          end
-
-          o.on("--include FILE,FILE..", Array, "Comma separated additional files to package with the box") do |i|
-            options[:include] = i
-          end
-
-          o.on("--vagrantfile FILE", "Vagrantfile to package with the box") do |v|
-            options[:vagrantfile] = v
-          end
-        end
-
-        # Parse the options
-        argv = parse_options(opts)
-        return if !argv
-
-        @logger.debug("package options: #{options.inspect}")
-        if options[:base]
-          package_base(options)
-        else
-          package_target(argv[0], options)
-        end
-
-        # Success, exit status 0
-        0
-      end
-
-      protected
-
-      def package_base(options)
-        # XXX: This whole thing is hardcoded and very temporary. The whole
-        # `vagrant package --base` process is deprecated for something much
-        # better in the future. We just hardcode this to keep VirtualBox working
-        # for now.
-        provider = Vagrant.plugin("2").manager.providers[:virtualbox]
-        tmp_data_directory = File.join(@env.tmp_path, SecureRandom.uuid)
-        FileUtils.mkdir_p(tmp_data_directory)
-        begin
-          vm = Vagrant::Machine.new(
-            options[:base],
-            :virtualbox, provider[0], nil, provider[1],
-            @env.vagrantfile.config,
-            Pathname.new(tmp_data_directory), nil,
-            @env, @env.vagrantfile, true)
-          @logger.debug("Packaging base VM: #{vm.name}")
-          package_vm(vm, options)
-        ensure
-          FileUtils.rm_rf(tmp_data_directory)
-        end
-      end
-
-      def package_target(name, options)
-        with_target_vms(name, single_target: true) do |vm|
-          @logger.debug("Packaging VM: #{vm.name}")
-          package_vm(vm, options)
-        end
-      end
-
-      def package_vm(vm, options)
-        opts = options.inject({}) do |acc, data|
-          k,v = data
-          acc["package.#{k}"] = v
-          acc
-        end
-
-        vm.action(:package, opts)
-      end
-    end
-  end
-end

data/vendor/bundle/ruby/2.4.0/bundler/gems/vagrant-04f7215b5e3f/plugins/commands/package/plugin.rb

@@ -1,18 +0,0 @@
-require "vagrant"
-
-module VagrantPlugins
-  module CommandPackage
-    class Plugin < Vagrant.plugin("2")
-      name "package command"
-      description <<-DESC
-      The `package` command will take a previously existing Vagrant
-      environment and package it into a box file.
-      DESC
-
-      command("package") do
-        require File.expand_path("../command", __FILE__)
-        Command
-      end
-    end
-  end
-end

data/vendor/bundle/ruby/2.4.0/bundler/gems/vagrant-04f7215b5e3f/plugins/commands/plugin/action/expunge_plugins.rb

@@ -1,66 +0,0 @@
-require "vagrant/plugin/manager"
-
-module VagrantPlugins
-  module CommandPlugin
-    module Action
-      # This middleware removes user installed plugins by
-      # removing:
-      #   * ~/.vagrant.d/plugins.json
-      #   * ~/.vagrant.d/gems
-      # Usage should be restricted to when a repair is
-      # unsuccessful and the only reasonable option remaining
-      # is to re-install all plugins
-      class ExpungePlugins
-        def initialize(app, env)
-          @app = app
-        end
-
-        def call(env)
-          if !env[:force]
-
-            result = nil
-            attempts = 0
-            while attempts < 5 && result.nil?
-              attempts += 1
-              result = env[:ui].ask(
-                I18n.t("vagrant.commands.plugin.expunge_confirm") +
-                  " [N]: "
-              )
-              result = result.to_s.downcase.strip
-              result = "n" if result.empty?
-              if !["y", "yes", "n", "no"].include?(result)
-                result = nil
-                env[:ui].error("Please answer Y or N")
-              else
-                result = result[0,1]
-              end
-            end
-
-            if result != 'y'
-              abort_action = true
-            end
-          end
-
-          if !abort_action
-            plugins_json = File.join(env[:home_path], "plugins.json")
-            plugins_gems = env[:gems_path]
-
-            if File.exist?(plugins_json)
-              FileUtils.rm(plugins_json)
-            end
-
-            if File.directory?(plugins_gems)
-              FileUtils.rm_rf(plugins_gems)
-            end
-
-            env[:ui].info(I18n.t("vagrant.commands.plugin.expunge_complete"))
-
-            @app.call(env)
-          else
-            env[:ui].info(I18n.t("vagrant.commands.plugin.expunge_aborted"))
-          end
-        end
-      end
-    end
-  end
-end

data/vendor/bundle/ruby/2.4.0/bundler/gems/vagrant-04f7215b5e3f/plugins/commands/plugin/action/install_gem.rb

@@ -1,75 +0,0 @@
-require "log4r"
-require "vagrant/plugin/manager"
-require "vagrant/util/platform"
-
-module VagrantPlugins
-  module CommandPlugin
-    module Action
-      # This action takes the `:plugin_name` variable in the environment
-      # and installs it using the RubyGems API.
-      class InstallGem
-        def initialize(app, env)
-          @app    = app
-          @logger = Log4r::Logger.new("vagrant::plugins::plugincommand::installgem")
-        end
-
-        def call(env)
-          entrypoint  = env[:plugin_entry_point]
-          plugin_name = env[:plugin_name]
-          sources     = env[:plugin_sources]
-          version     = env[:plugin_version]
-
-          # Install the gem
-          plugin_name_label = plugin_name
-          plugin_name_label += " --version '#{version}'" if version
-          env[:ui].info(I18n.t("vagrant.commands.plugin.installing",
-                               name: plugin_name_label))
-
-          manager = Vagrant::Plugin::Manager.instance
-          plugin_spec = manager.install_plugin(
-            plugin_name,
-            version: version,
-            require: entrypoint,
-            sources: sources,
-            verbose: !!env[:plugin_verbose],
-          )
-
-          # Record it so we can uninstall if something goes wrong
-          @installed_plugin_name = plugin_spec.name
-
-          # Tell the user
-          env[:ui].success(I18n.t("vagrant.commands.plugin.installed",
-                                  name: plugin_spec.name,
-                                  version: plugin_spec.version.to_s))
-
-          # If the plugin's spec includes a post-install message display it
-          post_install_message = plugin_spec.post_install_message
-          if post_install_message
-            if post_install_message.is_a?(Array)
-              post_install_message = post_install_message.join(" ")
-            end
-
-            env[:ui].info(I18n.t("vagrant.commands.plugin.post_install",
-                                 name: plugin_spec.name,
-                                 message: post_install_message.to_s))
-          end
-
-          # Continue
-          @app.call(env)
-        end
-
-        def recover(env)
-          # If any error happens, we uninstall it and remove it from
-          # the state file. We can only do this if we successfully installed
-          # the gem in the first place.
-          if @installed_plugin_name
-            new_env = env.dup
-            new_env.delete(:interrupted)
-            new_env[:plugin_name] = @installed_plugin_name
-            new_env[:action_runner].run(Action.action_uninstall, new_env)
-          end
-        end
-      end
-    end
-  end
-end

data/vendor/bundle/ruby/2.4.0/bundler/gems/vagrant-04f7215b5e3f/plugins/commands/plugin/action/license_plugin.rb

@@ -1,45 +0,0 @@
-require "fileutils"
-require "pathname"
-require "rubygems"
-require "set"
-
-require "log4r"
-
-module VagrantPlugins
-  module CommandPlugin
-    module Action
-      # This middleware licenses a plugin by copying the license file to
-      # the proper place.
-      class LicensePlugin
-        def initialize(app, env)
-          @app    = app
-          @logger = Log4r::Logger.new("vagrant::plugins::plugincommand::license")
-        end
-
-        def call(env)
-          # Verify the license file exists
-          license_file = Pathname.new(env[:plugin_license_path])
-          if !license_file.file?
-            raise Vagrant::Errors::PluginInstallLicenseNotFound,
-              name: env[:plugin_name],
-              path: license_file.to_s
-          end
-
-          # Copy it in.
-          final_path = env[:home_path].join("license-#{env[:plugin_name]}.lic")
-          @logger.info("Copying license from: #{license_file}")
-          @logger.info("Copying license to: #{final_path}")
-          env[:ui].info(I18n.t("vagrant.commands.plugin.installing_license",
-                               name: env[:plugin_name]))
-          FileUtils.cp(license_file, final_path)
-
-          # Installed!
-          env[:ui].success(I18n.t("vagrant.commands.plugin.installed_license",
-                                 name: env[:plugin_name]))
-
-          @app.call(env)
-        end
-      end
-    end
-  end
-end