vagrant-unbundled 2.1.4.0 → 2.2.0.0

data/plugins/commands/cloud/box/delete.rb

@@ -0,0 +1,65 @@
+require 'optparse'
+
+module VagrantPlugins
+  module CloudCommand
+    module BoxCommand
+      module Command
+        class Delete < Vagrant.plugin("2", :command)
+          def execute
+            options = {}
+
+            opts = OptionParser.new do |o|
+              o.banner = "Usage: vagrant cloud box delete [options] organization/box-name"
+              o.separator ""
+              o.separator "Deletes box entry on Vagrant Cloud"
+              o.separator ""
+              o.separator "Options:"
+              o.separator ""
+
+              o.on("-u", "--username USERNAME_OR_EMAIL", String, "Vagrant Cloud username or email address") do |t|
+                options[:username] = u
+              end
+            end
+
+            # Parse the options
+            argv = parse_options(opts)
+            return if !argv
+            if argv.empty? || argv.length > 1
+              raise Vagrant::Errors::CLIInvalidUsage,
+                help: opts.help.chomp
+            end
+
+            @env.ui.warn(I18n.t("cloud_command.box.delete_warn", box: argv.first))
+            cont = @env.ui.ask(I18n.t("cloud_command.continue"))
+            return 1 if cont.strip.downcase != "y"
+
+            @client = VagrantPlugins::CloudCommand::Util.client_login(@env, options[:username])
+
+            box = argv.first.split('/', 2)
+            org = box[0]
+            box_name = box[1]
+            delete_box(org, box_name, options[:username], @client.token)
+          end
+
+          def delete_box(org, box_name, username, access_token)
+            server_url = VagrantPlugins::CloudCommand::Util.api_server_url
+            account = VagrantPlugins::CloudCommand::Util.account(username, access_token, server_url)
+            box = VagrantCloud::Box.new(account, box_name, nil, nil, nil, access_token)
+
+            begin
+              success = box.delete(org, box_name)
+              @env.ui.success(I18n.t("cloud_command.box.delete_success", org: org, box_name: box_name))
+              return 0
+            rescue VagrantCloud::ClientError => e
+              @env.ui.error(I18n.t("cloud_command.errors.box.delete_fail", org: org, box_name: box_name))
+              @env.ui.error(e)
+              return 1
+            end
+
+            return 1
+          end
+        end
+      end
+    end
+  end
+end

data/plugins/commands/cloud/box/plugin.rb

@@ -0,0 +1,19 @@
+require "vagrant"
+
+module VagrantPlugins
+  module CloudCommand
+    module BoxCommand
+      class Plugin < Vagrant.plugin("2")
+        name "vagrant cloud box"
+        description <<-DESC
+        Box life cycle commands for Vagrant Cloud
+        DESC
+
+        command(:box) do
+          require_relative "root"
+          Command::Root
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,77 @@
+module VagrantPlugins
+  module CloudCommand
+    module BoxCommand
+      module Command
+        class Root < Vagrant.plugin("2", :command)
+          def self.synopsis
+            "Commands to manage boxes on Vagrant Cloud"
+          end
+
+          def initialize(argv, env)
+            super
+
+            @main_args, @sub_command, @sub_args = split_main_and_subcommand(argv)
+            @subcommands = Vagrant::Registry.new
+            @subcommands.register(:create) do
+              require File.expand_path("../create", __FILE__)
+              Command::Create
+            end
+            @subcommands.register(:delete) do
+              require File.expand_path("../delete", __FILE__)
+              Command::Delete
+            end
+            @subcommands.register(:show) do
+              require File.expand_path("../show", __FILE__)
+              Command::Show
+            end
+            @subcommands.register(:update) do
+              require File.expand_path("../update", __FILE__)
+              Command::Update
+            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 cloud box <subcommand> [<args>]"
+              opts.separator ""
+              opts.separator "Commands to manage boxes on Vagrant Cloud"
+              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 subcommand run `vagrant cloud box <subcommand> -h`"
+            end
+
+            @env.ui.info(opts.help, prefix: false)
+          end
+        end
+      end
+    end
+  end
+end

data/plugins/commands/cloud/box/show.rb

@@ -0,0 +1,74 @@
+require 'optparse'
+
+module VagrantPlugins
+  module CloudCommand
+    module BoxCommand
+      module Command
+        class Show < Vagrant.plugin("2", :command)
+          def execute
+            options = {}
+
+            opts = OptionParser.new do |o|
+              o.banner = "Usage: vagrant cloud box show [options] organization/box-name"
+              o.separator ""
+              o.separator "Displays a boxes attributes on Vagrant Cloud"
+              o.separator ""
+              o.separator "Options:"
+              o.separator ""
+
+              o.on("-u", "--username USERNAME_OR_EMAIL", String, "Vagrant Cloud username or email address") do |u|
+                options[:username] = u
+              end
+              o.on("--versions VERSION", String, "Display box information for a specific version") do |v|
+                options[:version] = v
+              end
+            end
+
+            # Parse the options
+            argv = parse_options(opts)
+            return if !argv
+            if argv.empty? || argv.length > 1
+              raise Vagrant::Errors::CLIInvalidUsage,
+                help: opts.help.chomp
+            end
+
+            @client = VagrantPlugins::CloudCommand::Util.client_login(@env, options[:username])
+            box = argv.first.split('/', 2)
+
+            show_box(box[0], box[1], options, @client.token)
+          end
+
+          def show_box(org, box_name, options, access_token)
+            username = options[:username]
+
+            server_url = VagrantPlugins::CloudCommand::Util.api_server_url
+            account = VagrantPlugins::CloudCommand::Util.account(username, access_token, server_url)
+            box = VagrantCloud::Box.new(account, box_name, nil, nil, nil, access_token)
+
+            begin
+              success = box.read(org, box_name)
+
+              if options[:version]
+                # show *this* version only
+                results = success["versions"].select{ |v| v if v["version"] == options[:version] }.first
+                if !results
+                  @env.ui.warn(I18n.t("cloud_command.box.show_filter_empty", version: options[:version], org: org, box_name: box_name))
+                  return 0
+                end
+              else
+                results = success
+              end
+              results = results.delete_if { |_, v| v.nil? }
+              VagrantPlugins::CloudCommand::Util.format_box_results(results, @env)
+              return 0
+            rescue VagrantCloud::ClientError => e
+              @env.ui.error(I18n.t("cloud_command.errors.box.show_fail", org: org,box_name:box_name))
+              @env.ui.error(e)
+              return 1
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/plugins/commands/cloud/box/update.rb

@@ -0,0 +1,71 @@
+require 'optparse'
+
+module VagrantPlugins
+  module CloudCommand
+    module BoxCommand
+      module Command
+        class Update < Vagrant.plugin("2", :command)
+          def execute
+            options = {}
+
+            opts = OptionParser.new do |o|
+              o.banner = "Usage: vagrant cloud box update [options] organization/box-name"
+              o.separator ""
+              o.separator "Updates a box entry on Vagrant Cloud"
+              o.separator ""
+              o.separator "Options:"
+              o.separator ""
+
+              o.on("-d", "--description DESCRIPTION", "Full description of the box") do |d|
+                options[:description] = d
+              end
+              o.on("-u", "--username", "The username of the organization that will own the box") do |u|
+                options[:username] = u
+              end
+              o.on("-s", "--short-description DESCRIPTION", "Short description of the box") do |s|
+                options[:short_description] = s
+              end
+              o.on("-p", "--private", "Makes box private") do |p|
+                options[:private] = p
+              end
+            end
+
+            # Parse the options
+            argv = parse_options(opts)
+            return if !argv
+            if argv.empty? || argv.length > 1 || options.length == 0
+              raise Vagrant::Errors::CLIInvalidUsage,
+                help: opts.help.chomp
+            end
+
+            @client = VagrantPlugins::CloudCommand::Util.client_login(@env, options[:username])
+            box = argv.first.split('/', 2)
+
+            update_box(box[0], box[1], options, @client.token)
+          end
+
+          def update_box(org, box_name, options, access_token)
+            server_url = VagrantPlugins::CloudCommand::Util.api_server_url
+            account = VagrantPlugins::CloudCommand::Util.account(options[:username], access_token, server_url)
+            box = VagrantCloud::Box.new(account, box_name, nil, nil, nil, access_token)
+
+            options[:organization] = org
+            options[:name] = box_name
+            begin
+              success = box.update(options)
+              @env.ui.success(I18n.t("cloud_command.box.update_success", org: org, box_name: box_name))
+              success = success.delete_if{|_, v|v.nil?}
+              VagrantPlugins::CloudCommand::Util.format_box_results(success, @env)
+              return 0
+            rescue VagrantCloud::ClientError => e
+              @env.ui.error(I18n.t("cloud_command.errors.box.update_fail", org: org, box_name: box_name))
+              @env.ui.error(e)
+              return 1
+            end
+            return 1
+          end
+        end
+      end
+    end
+  end
+end

data/plugins/commands/cloud/client/client.rb

@@ -0,0 +1,264 @@
+require "rest_client"
+require "vagrant_cloud"
+require "vagrant/util/downloader"
+require "vagrant/util/presence"
+require Vagrant.source_root.join("plugins/commands/cloud/errors")
+
+module VagrantPlugins
+  module CloudCommand
+    class Client
+      ######################################################################
+      # Class that deals with managing users 'local' token for Vagrant Cloud
+      ######################################################################
+      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::cloud::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
+        Vagrant::Util::CredentialScrubber.sensitive(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}'")
+
+        Vagrant::Util::CredentialScrubber.sensitive(password)
+        response = post(
+          "/api/v1/authenticate", {
+            user: {
+              login: username_or_email,
+              password: password
+            },
+            token: {
+              description: description
+            },
+            two_factor: {
+              code: code
+            }
+          }
+        )
+
+        Vagrant::Util::CredentialScrubber.sensitive(response["token"])
+        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}...")
+
+        Vagrant::Util::CredentialScrubber.sensitive(password)
+        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
+
+        @logger.debug("Got an unexpected error:")
+        @logger.debug(e.inspect)
+        raise Errors::Unexpected, error: 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/cloud/errors.rb

@@ -0,0 +1,28 @@
+module VagrantPlugins
+  module CloudCommand
+    module Errors
+      class Error < Vagrant::Errors::VagrantError
+        error_namespace("cloud_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 Unexpected < Error
+        error_key(:unexpected_error)
+      end
+
+      class TwoFactorRequired < Error
+      end
+    end
+  end
+end

data/plugins/commands/cloud/list.rb

@@ -0,0 +1,52 @@
+require 'optparse'
+
+module VagrantPlugins
+  module CloudCommand
+    module Command
+      class List < Vagrant.plugin("2", :command)
+        def execute
+          options = {}
+
+          opts = OptionParser.new do |o|
+            o.banner = "Usage: vagrant cloud list [options] organization"
+            o.separator ""
+            o.separator "Search for boxes managed by a specific user/organization"
+            o.separator ""
+            o.separator "Options:"
+            o.separator ""
+
+            o.on("-j", "--json", "Formats results in JSON") do |j|
+              options[:check] = j
+            end
+            o.on("-l", "--limit", Integer, "Max number of search results (default is 25)") do |l|
+              options[:check] = l
+            end
+            o.on("-p", "--provider", "Comma separated list of providers to filter search. Defaults to all.") do |p|
+              options[:check] = p
+            end
+            o.on("-s", "--sort-by", "Column to sort list (created, downloads, updated)") do |s|
+              options[:check] = s
+            end
+            o.on("-u", "--username USERNAME_OR_EMAIL", String, "Vagrant Cloud username or email address") do |t|
+              options[:username] = u
+            end
+          end
+
+          # Parse the options
+          argv = parse_options(opts)
+          return if !argv
+          if argv.length > 1
+            raise Vagrant::Errors::CLIInvalidUsage,
+              help: opts.help.chomp
+          end
+
+          @client = VagrantPlugins::CloudCommand::Util.client_login(@env, options[:username])
+
+          # TODO: This endpoint is not implemented yet
+
+          0
+        end
+      end
+    end
+  end
+end