vagrant-unbundled 2.2.7.0 → 2.2.16.0

data/lib/vagrant/action/builtin/after_trigger.rb

@@ -1,31 +0,0 @@
-module Vagrant
-  module Action
-    module Builtin
-      # This class is intended to be used by the Action::Warden class for executing
-      # action triggers before any given action.
-      #
-      # @param [Symbol] action_name - name to fire trigger on
-      # @param [Vagrant::Plugin::V2::Triger] triggers - trigger object
-      class AfterTriggerAction
-        # @param [Symbol] action_name - The action class name to fire trigger on
-        # @param [Vagrant::Plugin::V2::Triger] triggers - trigger object
-        def initialize(app, env, action_name, triggers)
-          @app         = app
-          @env         = env
-          @triggers    = triggers
-          @action_name = action_name
-        end
-
-        def call(env)
-          machine = env[:machine]
-          machine_name = machine.name if machine
-
-          @triggers.fire_triggers(@action_name, :after, machine_name, :action) if Vagrant::Util::Experimental.feature_enabled?("typed_triggers");
-
-          # Carry on
-          @app.call(env)
-        end
-      end
-    end
-  end
-end

data/lib/vagrant/action/builtin/before_trigger.rb

@@ -1,28 +0,0 @@
-module Vagrant
-  module Action
-    module Builtin
-      # This class is intended to be used by the Action::Warden class for executing
-      # action triggers before any given action.
-      class BeforeTriggerAction
-        # @param [Symbol] action_name - The action class name to fire trigger on
-        # @param [Vagrant::Plugin::V2::Triger] triggers - trigger object
-        def initialize(app, env, action_name, triggers)
-          @app         = app
-          @env         = env
-          @triggers    = triggers
-          @action_name = action_name
-        end
-
-        def call(env)
-          machine = env[:machine]
-          machine_name = machine.name if machine
-
-          @triggers.fire_triggers(@action_name, :before, machine_name, :action) if Vagrant::Util::Experimental.feature_enabled?("typed_triggers");
-
-          # Carry on
-          @app.call(env)
-        end
-      end
-    end
-  end
-end

data/plugins/commands/login/client.rb

@@ -1,253 +0,0 @@
-require "rest_client"
-require "vagrant/util/downloader"
-require "vagrant/util/presence"
-
-module VagrantPlugins
-  module LoginCommand
-    class Client
-      APP = "app".freeze
-
-      include Vagrant::Util::Presence
-
-      attr_accessor :username_or_email
-      attr_accessor :password
-      attr_reader :two_factor_default_delivery_method
-      attr_reader :two_factor_delivery_methods
-
-      # Initializes a login client with the given Vagrant::Environment.
-      #
-      # @param [Vagrant::Environment] env
-      def initialize(env)
-        @logger = Log4r::Logger.new("vagrant::login::client")
-        @env    = env
-      end
-
-      # Removes the token, effectively logging the user out.
-      def clear_token
-        @logger.info("Clearing token")
-        token_path.delete if token_path.file?
-      end
-
-      # Checks if the user is logged in by verifying their authentication
-      # token.
-      #
-      # @return [Boolean]
-      def logged_in?
-        token = self.token
-        return false if !token
-
-        with_error_handling do
-          url = "#{Vagrant.server_url}/api/v1/authenticate" +
-            "?access_token=#{token}"
-          RestClient.get(url, content_type: :json)
-          true
-        end
-      rescue Errors::Unauthorized
-        false
-      end
-
-      # Login logs a user in and returns the token for that user. The token
-      # is _not_ stored unless {#store_token} is called.
-      #
-      # @param [String] description
-      # @param [String] code
-      # @return [String] token The access token, or nil if auth failed.
-      def login(description: nil, code: nil)
-        @logger.info("Logging in '#{username_or_email}'")
-
-        response = post(
-          "/api/v1/authenticate", {
-            user: {
-              login: username_or_email,
-              password: password
-            },
-            token: {
-              description: description
-            },
-            two_factor: {
-              code: code
-            }
-          }
-        )
-
-        response["token"]
-      end
-
-      # Requests a 2FA code
-      # @param [String] delivery_method
-      def request_code(delivery_method)
-        @env.ui.warn("Requesting 2FA code via #{delivery_method.upcase}...")
-
-        response = post(
-          "/api/v1/two-factor/request-code", {
-            user: {
-              login: username_or_email,
-              password: password
-            },
-            two_factor: {
-              delivery_method: delivery_method.downcase
-            }
-          }
-        )
-
-        two_factor = response['two_factor']
-        obfuscated_destination = two_factor['obfuscated_destination']
-
-        @env.ui.success("2FA code sent to #{obfuscated_destination}.")
-      end
-
-      # Issues a post to a Vagrant Cloud path with the given payload.
-      # @param [String] path
-      # @param [Hash] payload
-      # @return [Hash] response data
-      def post(path, payload)
-        with_error_handling do
-          url = File.join(Vagrant.server_url, path)
-
-          proxy   = nil
-          proxy ||= ENV["HTTPS_PROXY"] || ENV["https_proxy"]
-          proxy ||= ENV["HTTP_PROXY"]  || ENV["http_proxy"]
-          RestClient.proxy = proxy
-
-          response = RestClient::Request.execute(
-            method: :post,
-            url: url,
-            payload: JSON.dump(payload),
-            proxy: proxy,
-            headers: {
-              accept: :json,
-              content_type: :json,
-              user_agent: Vagrant::Util::Downloader::USER_AGENT,
-            },
-          )
-
-          JSON.load(response.to_s)
-        end
-      end
-
-      # Stores the given token locally, removing any previous tokens.
-      #
-      # @param [String] token
-      def store_token(token)
-        @logger.info("Storing token in #{token_path}")
-
-        token_path.open("w") do |f|
-          f.write(token)
-        end
-
-        nil
-      end
-
-      # Reads the access token if there is one. This will first read the
-      # `VAGRANT_CLOUD_TOKEN` environment variable and then fallback to the stored
-      # access token on disk.
-      #
-      # @return [String]
-      def token
-        if present?(ENV["VAGRANT_CLOUD_TOKEN"]) && token_path.exist?
-          @env.ui.warn <<-EOH.strip
-Vagrant detected both the VAGRANT_CLOUD_TOKEN environment variable and a Vagrant login
-token are present on this system. The VAGRANT_CLOUD_TOKEN environment variable takes
-precedence over the locally stored token. To remove this error, either unset
-the VAGRANT_CLOUD_TOKEN environment variable or remove the login token stored on disk:
-
-    ~/.vagrant.d/data/vagrant_login_token
-
-EOH
-        end
-
-        if present?(ENV["VAGRANT_CLOUD_TOKEN"])
-          @logger.debug("Using authentication token from environment variable")
-          return ENV["VAGRANT_CLOUD_TOKEN"]
-        end
-
-        if token_path.exist?
-          @logger.debug("Using authentication token from disk at #{token_path}")
-          return token_path.read.strip
-        end
-
-        if present?(ENV["ATLAS_TOKEN"])
-          @logger.warn("ATLAS_TOKEN detected within environment. Using ATLAS_TOKEN in place of VAGRANT_CLOUD_TOKEN.")
-          return ENV["ATLAS_TOKEN"]
-        end
-
-        @logger.debug("No authentication token in environment or #{token_path}")
-
-        nil
-      end
-
-      protected
-
-      def with_error_handling(&block)
-        yield
-      rescue RestClient::Unauthorized
-        @logger.debug("Unauthorized!")
-        raise Errors::Unauthorized
-      rescue RestClient::BadRequest => e
-        @logger.debug("Bad request:")
-        @logger.debug(e.message)
-        @logger.debug(e.backtrace.join("\n"))
-        parsed_response = JSON.parse(e.response)
-        errors = parsed_response["errors"].join("\n")
-        raise Errors::ServerError, errors: errors
-      rescue RestClient::NotAcceptable => e
-        @logger.debug("Got unacceptable response:")
-        @logger.debug(e.message)
-        @logger.debug(e.backtrace.join("\n"))
-
-        parsed_response = JSON.parse(e.response)
-
-        if two_factor = parsed_response['two_factor']
-          store_two_factor_information two_factor
-
-          if two_factor_default_delivery_method != APP
-            request_code two_factor_default_delivery_method
-          end
-
-          raise Errors::TwoFactorRequired
-        end
-
-        begin
-          errors = parsed_response["errors"].join("\n")
-          raise Errors::ServerError, errors: errors
-        rescue JSON::ParserError; end
-
-        raise "An unexpected error occurred: #{e.inspect}"
-      rescue SocketError
-        @logger.info("Socket error")
-        raise Errors::ServerUnreachable, url: Vagrant.server_url.to_s
-      end
-
-      def token_path
-        @env.data_dir.join("vagrant_login_token")
-      end
-
-      def store_two_factor_information(two_factor)
-        @two_factor_default_delivery_method =
-          two_factor['default_delivery_method']
-
-        @two_factor_delivery_methods =
-          two_factor['delivery_methods']
-
-        @env.ui.warn "2FA is enabled for your account."
-        if two_factor_default_delivery_method == APP
-          @env.ui.info "Enter the code from your authenticator."
-        else
-          @env.ui.info "Default method is " \
-            "'#{two_factor_default_delivery_method}'."
-        end
-
-        other_delivery_methods =
-          two_factor_delivery_methods - [APP]
-
-        if other_delivery_methods.any?
-          other_delivery_methods_sentence = other_delivery_methods
-            .map { |word| "'#{word}'" }
-            .join(' or ')
-          @env.ui.info "You can also type #{other_delivery_methods_sentence} " \
-            "to request a new code."
-        end
-      end
-    end
-  end
-end

data/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