vagrant 1.5.0 → 2.4.4

data/plugins/commands/cloud/publish.rb

@@ -0,0 +1,297 @@
+# Copyright (c) HashiCorp, Inc.
+# SPDX-License-Identifier: BUSL-1.1
+
+require 'optparse'
+require "vagrant/util/uploader"
+
+module VagrantPlugins
+  module CloudCommand
+    module Command
+      class Publish < Vagrant.plugin("2", :command)
+        include Util
+
+        def execute
+          options = {
+            architecture: Vagrant::Util::Platform.architecture,
+            direct_upload: true,
+          }
+
+          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("-a", "--architecture ARCH", String, "Architecture of guest box (defaults to current host architecture)") do |a|
+              options[:architecture] = a
+            end
+            o.on("--url URL", String, "Remote URL to download this provider (cannot be used with provider-file)") 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", "--[no-]force", "Disables confirmation to create or update box") do |f|
+              options[:force] = f
+            end
+            o.on("-p", "--[no-]private", "Makes box private") do |p|
+              options[:private] = p
+            end
+            o.on("-r", "--[no-]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("-c", "--checksum CHECKSUM_VALUE", String, "Checksum of the box for this provider. --checksum-type option is required.") do |c|
+              options[:checksum] = c
+            end
+            o.on("-C", "--checksum-type TYPE", String, "Type of checksum used (md5, sha1, sha256, sha384, sha512). --checksum option is required.") do |c|
+              options[:checksum_type] = c
+            end
+            o.on("--[no-]direct-upload", "Upload asset directly to backend storage") do |d|
+              options[:direct_upload] = d
+            end
+            o.on("--[no-]default-architecture", "Mark as default architecture for specific provider") do |d|
+              options[:default_architecture] = d
+            end
+          end
+
+          # Parse the options
+          argv = parse_options(opts)
+          return if !argv
+
+          if argv.length < 3 || # missing required arguments
+              argv.length > 4 || # too many arguments
+              (argv.length < 4 && !options.key?(:url)) || # file argument required if url is not provided
+              (argv.length > 3 && options.key?(:url)) # cannot provide url and file argument
+            raise Vagrant::Errors::CLIInvalidUsage,
+              help: opts.help.chomp
+          end
+
+          org, box_name = argv.first.split('/', 2)
+          _, version, provider_name, box_file = argv
+
+          if box_file && !File.file?(box_file)
+            raise Vagrant::Errors::BoxFileNotExist,
+              file: box_file
+          end
+
+          @client = client_login(@env)
+          params = options.slice(:private, :release, :url, :short_description,
+            :description, :version_description, :checksum, :checksum_type,
+            :architecture, :default_architecture)
+
+          # Display output to user describing action to be taken
+          display_preamble(org, box_name, version, provider_name, params)
+
+          if !options[:force]
+            cont = @env.ui.ask(I18n.t("cloud_command.continue"))
+            return 1 if cont.strip.downcase != "y"
+          end
+
+          # Load up all the models we'll need to publish the asset
+          box = load_box(org, box_name, @client.token)
+          box_v = load_box_version(box, version)
+          box_p = load_version_provider(box_v, provider_name, params[:architecture])
+
+          # Update all the data
+          set_box_info(box, params.slice(:private, :short_description, :description))
+          set_version_info(box_v, params.slice(:version_description))
+          set_provider_info(box_p, params.slice(
+            :architecture,
+            :checksum,
+            :checksum_type,
+            :default_architecture,
+            :url))
+
+          # Save any updated state
+          @env.ui.warn(I18n.t("cloud_command.publish.box_save"))
+          box.save
+
+          # If we have a box file asset, upload it
+          if box_file
+            upload_box_file(box_p, box_file, options.slice(:direct_upload))
+          end
+
+          # If configured to release the box, release it
+          if options[:release] && !box_v.released?
+            release_version(box_v)
+          end
+
+          # And we're done!
+          @env.ui.success(I18n.t("cloud_command.publish.complete", org: org, box_name: box_name))
+          format_box_results(box_p, @env)
+          0
+        rescue VagrantCloud::Error => err
+          @env.ui.error(I18n.t("cloud_command.errors.publish.fail", org: org, box_name: box_name))
+          @env.ui.error(err.message)
+          1
+        end
+
+        # Upload the file for the given box provider
+        #
+        # @param [VagrantCloud::Box::Provider] provider Vagrant Cloud box version provider
+        # @param [String] box_file Path to local asset for upload
+        # @param [Hash] options
+        # @option options [Boolean] :direct_upload Upload directly to backend storage
+        # @return [nil]
+        def upload_box_file(provider, box_file, options={})
+          box_file = File.absolute_path(box_file)
+          @env.ui.info(I18n.t("cloud_command.publish.upload_provider", file: box_file))
+          # Include size check on file and disable direct if over 5G
+          if options[:direct_upload]
+            fsize = File.stat(box_file).size
+            if fsize > (5 * Vagrant::Util::Numeric::GIGABYTE)
+              box_size = Vagrant::Util::Numeric.bytes_to_string(fsize)
+              @env.ui.warn(I18n.t("cloud_command.provider.direct_disable", size: box_size))
+              options[:direct_upload] = false
+            end
+          end
+
+          provider.upload(direct: options[:direct_upload]) do |upload_url|
+            Vagrant::Util::Uploader.new(upload_url, box_file, ui: @env.ui, method: :put).upload!
+          end
+          nil
+        end
+
+        # Release the box version
+        #
+        # @param [VagrantCloud::Box::Version] version Vagrant Cloud box version
+        # @return [nil]
+        def release_version(version)
+          @env.ui.info(I18n.t("cloud_command.publish.release"))
+          version.release
+          nil
+        end
+
+        # Set any box related attributes that were provided
+        #
+        # @param [VagrantCloud::Box] box Vagrant Cloud box
+        # @param [Hash] options
+        # @option options [Boolean] :private Box access is private
+        # @option options [String] :short_description Short description of box
+        # @option options [String] :description Full description of box
+        # @return [VagrantCloud::Box]
+        def set_box_info(box, options={})
+          box.private = options[:private] if options.key?(:private)
+          box.short_description = options[:short_description] if options.key?(:short_description)
+          box.description = options[:description] if options.key?(:description)
+          box
+        end
+
+        # Set any version related attributes that were provided
+        #
+        # @param [VagrantCloud::Box::Version] version Vagrant Cloud box version
+        # @param [Hash] options
+        # @option options [String] :version_description Description for this version
+        # @return [VagrantCloud::Box::Version]
+        def set_version_info(version, options={})
+          version.description = options[:version_description] if options.key?(:version_description)
+          version
+        end
+
+        # Set any provider related attributes that were provided
+        #
+        # @param [VagrantCloud::Box::Provider] provider Vagrant Cloud box version provider
+        # @param [Hash] options
+        # @option options [String] architecture Guest architecture of box
+        # @option options [String] :url Remote URL for self hosted
+        # @option options [String] :checksum_type Type of checksum value provided
+        # @option options [String] :checksum Checksum of the box asset
+        # @option options [Boolean] :default_architecture Default architecture for named provider
+        # @return [VagrantCloud::Box::Provider]
+        def set_provider_info(provider, options={})
+          provider.url = options[:url] if options.key?(:url)
+          provider.checksum_type = options[:checksum_type] if options.key?(:checksum_type)
+          provider.checksum = options[:checksum] if options.key?(:checksum)
+          provider.architecture = options[:architecture] if options.key?(:architecture)
+          provider.default_architecture = options[:default_architecture] if options.key?(:default_architecture)
+          provider
+        end
+
+        # Load the requested version provider
+        #
+        # @param [VagrantCloud::Box::Version] version The version of the Vagrant Cloud box
+        # @param [String] provider_name Name of the provider
+        # @return [VagrantCloud::Box::Provider]
+        def load_version_provider(version, provider_name, architecture)
+          provider = version.providers.detect { |pv|
+            pv.name == provider_name &&
+              pv.architecture == architecture
+          }
+          return provider if provider
+          version.add_provider(provider_name, architecture)
+        end
+
+        # Load the requested box version
+        #
+        # @param [VagrantCloud::Box] box The Vagrant Cloud box
+        # @param [String] version Version of the box
+        # @return [VagrantCloud::Box::Version]
+        def load_box_version(box, version)
+          v = box.versions.detect { |v| v.version == version }
+          return v if v
+          box.add_version(version)
+        end
+
+        # Load the requested box
+        #
+        # @param [String] org Organization name for box
+        # @param [String] box_name Name of the box
+        # @param [String] access_token User access token
+        # @return [VagrantCloud::Box]
+        def load_box(org, box_name, access_token)
+          account = VagrantCloud::Account.new(
+            custom_server: api_server_url,
+            access_token: access_token
+          )
+          box = account.organization(name: org).boxes.detect { |b| b.name == box_name }
+          return box if box
+          account.organization(name: org).add_box(box_name)
+        end
+
+        # Display publishing information to user before starting process
+        #
+        # @param [String] org Organization name
+        # @param [String] box_name Name of the box to publish
+        # @param [String] version Version of the box to publish
+        # @param [String] provider_name Name of the provider being published
+        # @param [Hash] options
+        # @option options [String] :architecture Name of architecture of provider being published#
+        # @option options [Boolean] :private Box is private
+        # @option options [Boolean] :release Box should be released
+        # @option options [String] :url Remote URL for self-hosted boxes
+        # @option options [Boolean] :default_architecture Architecture is default for provider name
+        # @option options [String] :description Description of the box
+        # @option options [String] :short_description Short description of the box
+        # @option options [String] :version_description Description of the box version
+        # @return [nil]
+        def display_preamble(org, box_name, version, provider_name, options={})
+          @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.architecture",
+            architecture: options[:architecture]))
+          @env.ui.info(I18n.t("cloud_command.publish.confirm.default_architecture")) if options[:default_architecture]
+          @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]
+          nil
+        end
+      end
+    end
+  end
+end

data/plugins/commands/cloud/root.rb

@@ -0,0 +1,108 @@
+# Copyright (c) HashiCorp, Inc.
+# SPDX-License-Identifier: BUSL-1.1
+
+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"
+            if !Vagrant.server_mode?
+              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
+            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,102 @@
+# Copyright (c) HashiCorp, Inc.
+# SPDX-License-Identifier: BUSL-1.1
+
+require 'optparse'
+
+module VagrantPlugins
+  module CloudCommand
+    module Command
+      class Search < Vagrant.plugin("2", :command)
+        include Util
+
+        def execute
+          options = {quiet: true}
+
+          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("-a", "--architecture ARCH", "Filter search results to a single architecture. Defaults to all.") do |a|
+              options[:architecture] = a
+            end
+            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("--[no-]auth", "Authenticate with Vagrant Cloud if required before searching") do |l|
+              options[:quiet] = !l
+            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 = client_login(@env, options.slice(:quiet))
+          query = argv.first
+
+          options[:limit] = 25 if !(options[:limit].to_i < 1) && !options[:limit]
+
+          search(query, @client&.token, options)
+        end
+
+        # Perform requested search and display results to user
+        #
+        # @param [String] query Search query string
+        # @param [Hash] options
+        # @option options [String] :provider Filter by provider
+        # @option options [String] :sort Field to sort results
+        # @option options [Integer] :limit Number of results to display
+        # @option options [Integer] :page Page of results to display
+        # @param [String] access_token User access token
+        # @return [Integer]
+        def search(query, access_token, options={})
+          account = VagrantCloud::Account.new(
+            custom_server: api_server_url,
+            access_token: access_token
+          )
+          params = {query: query}.merge(options.slice(:architecture, :provider, :sort, :order, :limit, :page))
+          result = account.searcher.search(**params)
+
+          if result.boxes.empty?
+            @env.ui.warn(I18n.t("cloud_command.search.no_results", query: query))
+            return 0
+          end
+
+          format_search_results(result.boxes, options[:short], options[:json], @env)
+          0
+        rescue VagrantCloud::Error => e
+          @env.ui.error(I18n.t("cloud_command.errors.search.fail"))
+          @env.ui.error(e.message)
+          1
+        end
+      end
+    end
+  end
+end