vagrant-unbundled 2.1.4.0 → 2.2.0.0

data/plugins/commands/cloud/publish.rb

@@ -0,0 +1,165 @@
+require 'optparse'
+require "vagrant/util/uploader"
+
+module VagrantPlugins
+  module CloudCommand
+    module Command
+      class Publish < Vagrant.plugin("2", :command)
+        def execute
+          options = {}
+
+          opts = OptionParser.new do |o|
+            o.banner = "Usage: vagrant cloud publish [options] organization/box-name version provider-name [provider-file]"
+            o.separator ""
+            o.separator "Create and release a new Vagrant Box on Vagrant Cloud"
+            o.separator ""
+            o.separator "Options:"
+            o.separator ""
+
+            o.on("--box-version VERSION", String, "Version of box to create") do |v|
+              options[:box_version] = v
+            end
+            o.on("--url URL", String, "Remote URL to download this provider") do |u|
+              options[:url] = u
+            end
+            o.on("-d", "--description DESCRIPTION", String, "Full description of box") do |d|
+              options[:description] = d
+            end
+            o.on("--version-description DESCRIPTION", String, "Description of the version to create") do |v|
+              options[:version_description] = v
+            end
+            o.on("-f", "--force", "Disables confirmation to create or update box") do |f|
+              options[:force] = f
+            end
+            o.on("-p", "--private", "Makes box private") do |p|
+              options[:private] = p
+            end
+            o.on("-r", "--release", "Releases box") do |p|
+              options[:release] = p
+            end
+            o.on("-s", "--short-description DESCRIPTION", String, "Short description of the box") do |s|
+              options[:short_description] = 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.empty? || argv.length > 4 || argv.length < 3
+            raise Vagrant::Errors::CLIInvalidUsage,
+              help: opts.help.chomp
+          end
+
+          @client = VagrantPlugins::CloudCommand::Util.client_login(@env, options[:username])
+
+          box = argv.first.split('/', 2)
+          org = box[0]
+          box_name = box[1]
+          version = argv[1]
+          provider_name = argv[2]
+          box_file = argv[3] # path expand
+          publish_box(org, box_name, version, provider_name, box_file, options, @client.token)
+        end
+
+        def publish_box(org, box_name, version, provider_name, box_file, options, access_token)
+          server_url = VagrantPlugins::CloudCommand::Util.api_server_url
+
+          @env.ui.warn(I18n.t("cloud_command.publish.confirm.warn"))
+
+          @env.ui.info(I18n.t("cloud_command.publish.confirm.box", org: org,
+                              box_name: box_name, version: version, provider_name: provider_name))
+          @env.ui.info(I18n.t("cloud_command.publish.confirm.private")) if options[:private]
+          @env.ui.info(I18n.t("cloud_command.publish.confirm.release")) if options[:release]
+          @env.ui.info(I18n.t("cloud_command.publish.confirm.box_url",
+                             url: options[:url])) if options[:url]
+          @env.ui.info(I18n.t("cloud_command.publish.confirm.box_description",
+                             description: options[:description])) if options[:description]
+          @env.ui.info(I18n.t("cloud_command.publish.confirm.box_short_desc",
+                             short_description: options[:short_description])) if options[:short_description]
+          @env.ui.info(I18n.t("cloud_command.publish.confirm.version_desc",
+                             version_description: options[:version_description])) if options[:version_description]
+
+          if !options[:force]
+            cont = @env.ui.ask(I18n.t("cloud_command.continue"))
+            return 1 if cont.strip.downcase != "y"
+          end
+
+          account = VagrantPlugins::CloudCommand::Util.account(org, access_token, server_url)
+          box = VagrantCloud::Box.new(account, box_name, nil, options[:short_description], options[:description], access_token)
+          cloud_version = VagrantCloud::Version.new(box, version, nil, options[:version_description], access_token)
+          provider = VagrantCloud::Provider.new(cloud_version, provider_name, nil, options[:url], org, box_name, access_token)
+
+          ui = Vagrant::UI::Prefixed.new(@env.ui, "cloud")
+
+          begin
+            ui.info(I18n.t("cloud_command.publish.box_create"))
+            box.create
+          rescue VagrantCloud::ClientError => e
+            if e.error_code == 422
+              ui.warn(I18n.t("cloud_command.publish.update_continue", obj: "Box"))
+              box.update(options)
+            else
+              @env.ui.error(I18n.t("cloud_command.errors.publish.fail", org: org, box_name: box_name))
+              @env.ui.error(e)
+              return 1
+            end
+          end
+
+          begin
+            ui.info(I18n.t("cloud_command.publish.version_create"))
+            cloud_version.create_version
+          rescue VagrantCloud::ClientError => e
+            if e.error_code == 422
+              ui.warn(I18n.t("cloud_command.publish.update_continue", obj: "Version"))
+              cloud_version.update
+            else
+              @env.ui.error(I18n.t("cloud_command.errors.publish.fail", org: org, box_name: box_name))
+              @env.ui.error(e)
+              return 1
+            end
+          end
+
+          begin
+            ui.info(I18n.t("cloud_command.publish.provider_create"))
+            provider.create_provider
+          rescue VagrantCloud::ClientError => e
+            if e.error_code == 422
+              ui.warn(I18n.t("cloud_command.publish.update_continue", obj: "Provider"))
+              provider.update
+            else
+              @env.ui.error(I18n.t("cloud_command.errors.publish.fail", org: org, box_name: box_name))
+              @env.ui.error(e)
+              return 1
+            end
+          end
+
+          begin
+            if !options[:url]
+              box_file = File.absolute_path(box_file)
+              ui.info(I18n.t("cloud_command.publish.upload_provider", file: box_file))
+              ul = Vagrant::Util::Uploader.new(provider.upload_url, box_file, ui: @env.ui)
+              ul.upload!
+            end
+            if options[:release]
+              ui.info(I18n.t("cloud_command.publish.release"))
+              cloud_version.release
+            end
+            @env.ui.success(I18n.t("cloud_command.publish.complete", org: org, box_name: box_name))
+            success = box.read(org, box_name)
+            success = success.delete_if{|_, v|v.nil?}
+            VagrantPlugins::CloudCommand::Util.format_box_results(success, @env)
+            return 0
+          rescue Vagrant::Errors::UploaderError, VagrantCloud::ClientError => e
+            @env.ui.error(I18n.t("cloud_command.errors.publish.fail", org: org, box_name: box_name))
+            @env.ui.error(e)
+            return 1
+          end
+          return 1
+        end
+      end
+    end
+  end
+end

data/plugins/commands/cloud/root.rb

@@ -0,0 +1,104 @@
+module VagrantPlugins
+  module CloudCommand
+    module Command
+      class Root < Vagrant.plugin("2", :command)
+        def self.synopsis
+          "manages everything related to Vagrant Cloud"
+        end
+
+        def initialize(argv, env)
+          super
+
+          @main_args, @sub_command, @sub_args = split_main_and_subcommand(argv)
+          @subcommands = Vagrant::Registry.new
+          @subcommand_helptext = {}
+
+          @subcommands.register(:auth) do
+            require File.expand_path("../auth/root", __FILE__)
+            AuthCommand::Command::Root
+          end
+          @subcommand_helptext[:auth] = "For various authorization operations on Vagrant Cloud"
+
+          @subcommands.register(:box) do
+            require File.expand_path("../box/root", __FILE__)
+            BoxCommand::Command::Root
+          end
+          @subcommand_helptext[:box] = "For managing a Vagrant box entry on Vagrant Cloud"
+
+          # TODO: Uncomment this when API endpoint exists
+          #@subcommands.register(:list) do
+          #  require File.expand_path("../list", __FILE__)
+          #  List
+          #end
+          #@subcommand_helptext[:list] = "Displays a list of Vagrant boxes that the current user manages"
+
+          @subcommands.register(:search) do
+            require File.expand_path("../search", __FILE__)
+            Search
+          end
+          @subcommand_helptext[:search] = "Search Vagrant Cloud for available boxes"
+
+          @subcommands.register(:provider) do
+            require File.expand_path("../provider/root", __FILE__)
+            ProviderCommand::Command::Root
+          end
+          @subcommand_helptext[:provider] = "For managing a Vagrant box's provider options"
+
+          @subcommands.register(:publish) do
+            require File.expand_path("../publish", __FILE__)
+            Publish
+          end
+          @subcommand_helptext[:publish] = "A complete solution for creating or updating a new box on Vagrant Cloud"
+
+          @subcommands.register(:version) do
+            require File.expand_path("../version/root", __FILE__)
+            VersionCommand::Command::Root
+          end
+          @subcommand_helptext[:version] = "For managing a Vagrant box's versions"
+        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 <subcommand> [<args>]"
+            opts.separator ""
+            opts.separator "The cloud command can be used for taking actions against"
+            opts.separator "Vagrant Cloud like searching or uploading a Vagrant Box"
+            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.ljust(15)} #{@subcommand_helptext[key.to_sym]}"
+            end
+
+            opts.separator ""
+            opts.separator "For help on any individual subcommand run `vagrant cloud <subcommand> -h`"
+          end
+
+          @env.ui.info(opts.help, prefix: false)
+        end
+      end
+    end
+  end
+end

data/plugins/commands/cloud/search.rb

@@ -0,0 +1,83 @@
+require 'optparse'
+
+module VagrantPlugins
+  module CloudCommand
+    module Command
+      class Search < Vagrant.plugin("2", :command)
+        def execute
+          options = {}
+
+          opts = OptionParser.new do |o|
+            o.banner = "Usage: vagrant cloud search [options] query"
+            o.separator ""
+            o.separator "Search for boxes managed by a specific"
+            o.separator "user/organization on Vagrant Cloud"
+            o.separator ""
+            o.separator "Options:"
+            o.separator ""
+
+            o.on("-j", "--json", "Formats results in JSON") do |j|
+              options[:json] = j
+            end
+            o.on("-p", "--page PAGE", Integer, "The page to display Default: 1") do |j|
+              options[:page] = j
+            end
+            o.on("-s", "--short", "Shows a simple list of box names") do |s|
+              options[:short] = s
+            end
+            o.on("-o", "--order ORDER", String, "Order to display results ('desc' or 'asc') Default: 'desc'") do |o|
+              options[:order] = o
+            end
+            o.on("-l", "--limit LIMIT", Integer, "Max number of search results Default: 25") do |l|
+              options[:limit] = l
+            end
+            o.on("-p", "--provider PROVIDER", String, "Filter search results to a single provider. Defaults to all.") do |p|
+              options[:provider] = p
+            end
+            o.on("--sort-by SORT", "Field to sort results on (created, downloads, updated) Default: downloads") do |s|
+              options[:sort] = 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])
+          query = argv.first
+
+          options[:limit] = 25 if !(options[:limit].to_i < 1) && !options[:limit]
+
+          search(query, options, @client.token)
+        end
+
+        def search(query, options, access_token)
+          server_url = VagrantPlugins::CloudCommand::Util.api_server_url
+          search = VagrantCloud::Search.new(access_token, server_url)
+
+          begin
+            search_results = search.search(query, options[:provider], options[:sort], options[:order], options[:limit], options[:page])
+            if !search_results["boxes"].empty?
+              VagrantPlugins::CloudCommand::Util.format_search_results(search_results["boxes"], options[:short], options[:json], @env)
+            else
+              @env.ui.warn(I18n.t("cloud_command.search.no_results", query: query))
+            end
+            return 0
+          rescue VagrantCloud::ClientError => e
+            @env.ui.error(I18n.t("cloud_command.errors.search.fail"))
+            @env.ui.error(e)
+            return 1
+          end
+          return 1
+        end
+      end
+    end
+  end
+end

data/plugins/commands/cloud/util.rb

@@ -0,0 +1,206 @@
+module VagrantPlugins
+  module CloudCommand
+    class Util
+      class << self
+        # @param [String] username - Vagrant Cloud username
+        # @param [String] access_token - Vagrant Cloud Token used to authenticate
+        # @param [String] vagrant_cloud_server - Vagrant Cloud server to make API request
+        # @return [VagrantCloud::Account]
+        def account(username, access_token, vagrant_cloud_server)
+          if !defined?(@_account)
+            @_account = VagrantCloud::Account.new(username, access_token, vagrant_cloud_server)
+          end
+          @_account
+        end
+
+        def api_server_url
+          if Vagrant.server_url == Vagrant::DEFAULT_SERVER_URL
+            return "#{Vagrant.server_url}/api/v1"
+          else
+            return Vagrant.server_url
+          end
+        end
+
+        # @param [Vagrant::Environment] env
+        # @param [Hash] options
+        # @returns [VagrantPlugins::CloudCommand::Client]
+        def client_login(env, options)
+          if !defined?(@_client)
+            @_client = Client.new(env)
+            return @_client if @_client.logged_in?
+
+            # Let the user know what is going on.
+            env.ui.output(I18n.t("cloud_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
+
+            options = {} if !options
+            # Ask for the username
+            if options[:login]
+              @_client.username_or_email = options[:login]
+              env.ui.output("Vagrant Cloud username or email: #{@_client.username_or_email}")
+            else
+              @_client.username_or_email = env.ui.ask("Vagrant Cloud username or email: ")
+            end
+
+            @_client.password = env.ui.ask("Password (will be hidden): ", echo: false)
+
+            description_default = "Vagrant login from #{Socket.gethostname}"
+            if !options[:description]
+              description = env.ui.ask("Token description (Defaults to #{description_default.inspect}): ")
+            else
+              description = options[:description]
+              env.ui.output("Token description: #{description}")
+            end
+
+            description = description_default if description.empty?
+
+            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)
+            Vagrant::Util::CredentialScrubber.sensitive(token)
+            env.ui.success(I18n.t("cloud_command.logged_in"))
+            @_client
+          end
+          @_client
+        end
+
+        # ===================================================
+        # Modified from https://stackoverflow.com/a/28685559
+        # for printing arrays of hashes in formatted tables
+        # ===================================================
+
+        # @param [Vagrant::Environment] - env
+        # @param [Hash] - column_labels - A hash of key values for table labels (i.e. {:col1=>"COL1", :col2=>"COL2"})
+        # @param [Array] - results - An array of hashes
+        # @param [Array] - to_jrust_keys - An array of column keys that should be right justified (default is left justified for all columns)
+        def print_search_table(env, column_labels, results, to_rjust_keys)
+          columns = column_labels.each_with_object({}) { |(col,label),h|
+            h[col] = { label: label,
+                       width: [results.map { |g| g[col].size }.max, label.size].max
+                     }}
+
+          write_header(env, columns)
+          write_divider(env, columns)
+          results.each { |h| write_line(env, columns, h,to_rjust_keys) }
+          write_divider(env, columns)
+        end
+
+        def write_header(env, columns)
+          env.ui.info "| #{ columns.map { |_,g| g[:label].ljust(g[:width]) }.join(' | ') } |"
+        end
+
+        def write_divider(env, columns)
+          env.ui.info "+-#{ columns.map { |_,g| "-"*g[:width] }.join("-+-") }-+"
+        end
+
+        def write_line(env, columns,h,to_rjust_keys)
+          str = h.keys.map { |k|
+            if to_rjust_keys.include?(k)
+              h[k].rjust(columns[k][:width])
+            else
+              h[k].ljust(columns[k][:width])
+            end
+          }.join(" | ")
+          env.ui.info "| #{str} |"
+        end
+
+        # ===================================================
+        # ===================================================
+
+        # Takes a "mostly" flat key=>value hash from Vagrant Cloud
+        # and prints its results in a list
+        #
+        # @param [Hash] - results - A response hash from vagrant cloud
+        # @param [Vagrant::Environment] - env
+        def format_box_results(results, env)
+          # TODO: remove other description fields? Maybe leave "short"?
+          results.delete("description_html")
+
+          if results["current_version"]
+            versions = results.delete("versions")
+            results["providers"] = results["current_version"]["providers"]
+
+            results["old_versions"] = versions.map{ |v| v["version"] }[1..5].join(", ") + "..."
+          end
+
+
+          width = results.keys.map{|k| k.size}.max
+          results.each do |k,v|
+            if k == "versions"
+              v = v.map{ |ver| ver["version"] }.join(", ")
+            elsif k == "current_version"
+              v = v["version"]
+            elsif k == "providers"
+              v = v.map{ |p| p["name"] }.join(", ")
+            elsif k == "downloads"
+              v = format_downloads(v.to_s)
+            end
+
+            whitespace = width-k.size
+            env.ui.info "#{k}:" + "".ljust(whitespace) + " #{v}"
+          end
+        end
+
+        # Converts a string of numbers into a formatted number
+        #
+        # 1234 -> 1,234
+        #
+        # @param [String] - download_string
+        def format_downloads(download_string)
+          return download_string.reverse.gsub(/(\d{3})(?=\d)/, '\\1,').reverse
+        end
+
+
+        # @param [Array] search_results - Box search results from Vagrant Cloud
+        # @param [String,nil] short - determines if short version will be printed
+        # @param [String,nil] json - determines if json version will be printed
+        # @param [Vagrant::Environment] - env
+        def format_search_results(search_results, short, json, env)
+          result = []
+          search_results.each do |b|
+            box = {}
+            box = {
+              name: b["tag"],
+              version: b["current_version"]["version"],
+              downloads: format_downloads(b["downloads"].to_s),
+              providers: b["current_version"]["providers"].map{ |p| p["name"] }.join(",")
+            }
+            result << box
+          end
+
+          if short
+            result.map {|b| env.ui.info(b[:name])}
+          elsif json
+            env.ui.info(result.to_json)
+          else
+            column_labels = {}
+            columns = result.first.keys
+            columns.each do |c|
+              column_labels[c] = c.to_s.upcase
+            end
+            print_search_table(env, column_labels, result, [:downloads])
+          end
+        end
+      end
+    end
+  end
+end

data/plugins/commands/cloud/version/create.rb

@@ -0,0 +1,69 @@
+require 'optparse'
+
+module VagrantPlugins
+  module CloudCommand
+    module VersionCommand
+      module Command
+        class Create < Vagrant.plugin("2", :command)
+          def execute
+            options = {}
+
+            opts = OptionParser.new do |o|
+              o.banner = "Usage: vagrant cloud version create [options] organization/box-name version"
+              o.separator ""
+              o.separator "Creates a version entry on Vagrant Cloud"
+              o.separator ""
+              o.separator "Options:"
+              o.separator ""
+
+              o.on("-d", "--description DESCRIPTION", String, "A description for this version") do |d|
+                options[:description] = d
+              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.empty? || argv.length > 2
+              raise Vagrant::Errors::CLIInvalidUsage,
+                help: opts.help.chomp
+            end
+
+            @client = VagrantPlugins::CloudCommand::Util.client_login(@env, options[:username])
+            box = argv.first.split('/', 2)
+            org = box[0]
+            box_name = box[1]
+            version = argv[1]
+
+            create_version(org, box_name, version, @client.token, options)
+          end
+
+          def create_version(org, box_name, box_version, access_token, options)
+            org = options[:username] if options[:username]
+
+            server_url = VagrantPlugins::CloudCommand::Util.api_server_url
+            account = VagrantPlugins::CloudCommand::Util.account(org, access_token, server_url)
+            box = VagrantCloud::Box.new(account, box_name, nil, nil, nil, access_token)
+            version = VagrantCloud::Version.new(box, box_version, nil, options[:description], access_token)
+
+            begin
+              success = version.create_version
+              @env.ui.success(I18n.t("cloud_command.version.create_success", version: box_version, 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.version.create_fail", version: box_version, org: org, box_name: box_name))
+              @env.ui.error(e)
+              return 1
+            end
+            return 1
+          end
+        end
+      end
+    end
+  end
+end