vagrant-unbundled 2.1.4.0 → 2.2.0.0

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

@@ -0,0 +1,68 @@
+require 'optparse'
+
+module VagrantPlugins
+  module CloudCommand
+    module VersionCommand
+      module Command
+        class Delete < Vagrant.plugin("2", :command)
+          def execute
+            options = {}
+
+            opts = OptionParser.new do |o|
+              o.banner = "Usage: vagrant cloud version delete [options] organization/box-name version"
+              o.separator ""
+              o.separator "Deletes a version 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 > 2
+              raise Vagrant::Errors::CLIInvalidUsage,
+                help: opts.help.chomp
+            end
+
+            box = argv.first.split('/', 2)
+            org = box[0]
+            box_name = box[1]
+            version = argv[1]
+
+            @env.ui.warn(I18n.t("cloud_command.version.delete_warn", version: version, 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])
+
+            delete_version(org, box_name, version, options, @client.token)
+          end
+
+          def delete_version(org, box_name, box_version, options, access_token)
+            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, nil, access_token)
+
+            begin
+              success = version.delete
+              @env.ui.success(I18n.t("cloud_command.version.delete_success", version: box_version, org: org, box_name: box_name))
+              return 0
+            rescue VagrantCloud::ClientError => e
+              @env.ui.error(I18n.t("cloud_command.errors.version.delete_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

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

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

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

@@ -0,0 +1,69 @@
+require 'optparse'
+
+module VagrantPlugins
+  module CloudCommand
+    module VersionCommand
+      module Command
+        class Release < Vagrant.plugin("2", :command)
+          def execute
+            options = {}
+
+            opts = OptionParser.new do |o|
+              o.banner = "Usage: vagrant cloud version release [options] organization/box-name version"
+              o.separator ""
+              o.separator "Releases a version 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 > 2
+              raise Vagrant::Errors::CLIInvalidUsage,
+                help: opts.help.chomp
+            end
+
+            @env.ui.warn(I18n.t("cloud_command.version.release_warn", version: argv[1], 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]
+            version = argv[1]
+
+            release_version(org, box_name, version, @client.token, options)
+          end
+
+          def release_version(org, box_name, 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, version, nil, nil, access_token)
+
+            begin
+              success = version.release
+              @env.ui.success(I18n.t("cloud_command.version.release_success", version: 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.release_fail", version: version, 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/version/revoke.rb

@@ -0,0 +1,69 @@
+require 'optparse'
+
+module VagrantPlugins
+  module CloudCommand
+    module VersionCommand
+      module Command
+        class Revoke < Vagrant.plugin("2", :command)
+          def execute
+            options = {}
+
+            opts = OptionParser.new do |o|
+              o.banner = "Usage: vagrant cloud version revoke [options] organization/box-name version"
+              o.separator ""
+              o.separator "Revokes a version 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 > 2
+              raise Vagrant::Errors::CLIInvalidUsage,
+                help: opts.help.chomp
+            end
+
+            @env.ui.warn(I18n.t("cloud_command.version.revoke_warn", version: argv[1], 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]
+            version = argv[1]
+
+            revoke_version(org, box_name, version, @client.token, options)
+          end
+
+          def revoke_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, nil, access_token)
+
+            begin
+              success = version.revoke
+              @env.ui.success(I18n.t("cloud_command.version.revoke_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.revoke_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

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

@@ -0,0 +1,81 @@
+module VagrantPlugins
+  module CloudCommand
+    module VersionCommand
+      module Command
+        class Root < Vagrant.plugin("2", :command)
+          def self.synopsis
+            "Version commands"
+          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(:revoke) do
+              require File.expand_path("../revoke", __FILE__)
+              Command::Revoke
+            end
+            @subcommands.register(:release) do
+              require File.expand_path("../release", __FILE__)
+              Command::Release
+            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 version 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 version <subcommand> [<args>]"
+              opts.separator ""
+              opts.separator "For taking various actions against a Vagrant box's version attribute 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 version <subcommand> -h`"
+            end
+
+            @env.ui.info(opts.help, prefix: false)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,69 @@
+require 'optparse'
+
+module VagrantPlugins
+  module CloudCommand
+    module VersionCommand
+      module Command
+        class Update < Vagrant.plugin("2", :command)
+          def execute
+            options = {}
+
+            opts = OptionParser.new do |o|
+              o.banner = "Usage: vagrant cloud version update [options] organization/box-name version"
+              o.separator ""
+              o.separator "Updates a version entry on Vagrant Cloud"
+              o.separator ""
+              o.separator "Options:"
+              o.separator ""
+
+              o.on("-d", "--description DESCRIPTION", "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]
+
+            update_version(org, box_name, version, @client.token, options)
+          end
+
+          def update_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.update
+              @env.ui.success(I18n.t("cloud_command.version.update_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.update_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

data/plugins/commands/init/command.rb

@@ -14,7 +14,7 @@ module VagrantPlugins
           force: false,
           minimal: false,
           output: "Vagrantfile",
-          template: nil
+          template: ENV["VAGRANT_DEFAULT_TEMPLATE"]
         }
 
         opts = OptionParser.new do |o|

data/plugins/commands/login/plugin.rb

@@ -12,9 +12,10 @@ module VagrantPlugins
       DESC
 
       command(:login) do
-        require_relative "command"
+        require File.expand_path("../../cloud/auth/login", __FILE__)
         init!
-        Command
+        $stderr.puts "WARNING: This command has been deprecated in favor of `vagrant cloud auth login`"
+        VagrantPlugins::CloudCommand::AuthCommand::Command::Login
       end
 
       action_hook(:cloud_authenticated_boxes, :authenticate_box_url) do |hook|
@@ -26,7 +27,7 @@ module VagrantPlugins
 
       def self.init!
         return if defined?(@_init)
-        I18n.load_path << File.expand_path("../locales/en.yml", __FILE__)
+        I18n.load_path << File.expand_path("../../cloud/locales/en.yml", __FILE__)
         I18n.reload!
         @_init = true
       end

data/plugins/commands/powershell/command.rb

@@ -16,6 +16,9 @@ module VagrantPlugins
         opts = OptionParser.new do |o|
           o.banner = "Usage: vagrant powershell [-- extra powershell args]"
 
+          o.separator ""
+          o.separator "Opens a PowerShell session on the host to the guest"
+          o.separator "machine if both support powershell remoting."
           o.separator ""
           o.separator "Options:"
           o.separator ""

data/plugins/commands/powershell/plugin.rb

@@ -22,6 +22,7 @@ module VagrantPlugins
       def self.init!
         return if defined?(@_init)
         I18n.load_path << File.expand_path("templates/locales/command_ps.yml", Vagrant.source_root)
+        I18n.load_path << File.expand_path("templates/locales/comm_winrm.yml", Vagrant.source_root)
         I18n.reload!
         @_init = true
       end

data/plugins/commands/upload/command.rb

@@ -0,0 +1,236 @@
+require 'optparse'
+require "rubygems/package"
+
+module VagrantPlugins
+  module CommandUpload
+    class Command < Vagrant.plugin("2", :command)
+
+      VALID_COMPRESS_TYPES = [:tgz, :zip].freeze
+
+      def self.synopsis
+        "upload to machine via communicator"
+      end
+
+      def execute
+        options = {}
+
+        opts = OptionParser.new do |o|
+          o.banner = "Usage: vagrant upload [options] <source> [destination] [name|id]"
+          o.separator ""
+          o.separator "Options:"
+          o.separator ""
+
+          o.on("-t", "--temporary", "Upload source to temporary directory") do |t|
+            options[:temporary] = t
+          end
+
+          o.on("-c", "--compress", "Use gzip compression for upload") do |c|
+            options[:compress] = c
+          end
+
+          o.on("-C", "--compression-type=TYPE", "Type of compression to use (#{VALID_COMPRESS_TYPES.join(", ")})") do |c|
+            options[:compression_type] = c.to_sym
+            options[:compress] = true
+          end
+        end
+
+        argv = parse_options(opts)
+        return if !argv
+
+        case argv.size
+        when 3
+          source, destination, guest = argv
+        when 2, 1
+          source = argv[0]
+          if @env.active_machines.map(&:first).map(&:to_s).include?(argv[1])
+            guest = argv[1]
+          else
+            destination = argv[1]
+          end
+        else
+          raise Vagrant::Errors::CLIInvalidUsage, help: opts.help.chomp
+        end
+
+        # NOTE: We do this to handle paths on Windows like: "..\space dir\"
+        # because the final separater acts to escape the quote and ends up
+        # in the source value.
+        source = source.sub(/["']$/, "")
+        destination ||= File.basename(source)
+
+        if File.file?(source)
+          type = :file
+        elsif File.directory?(source)
+          type = :directory
+        else
+          raise Vagrant::Errors::UploadSourceMissing,
+            source: source
+        end
+
+        with_target_vms(guest, single_target: true) do |machine|
+          if options[:temporary]
+            if !machine.guest.capability?(:create_tmp_path)
+              raise Vagrant::Errors::UploadMissingTempCapability
+            end
+            extension = File.extname(source) if type == :file
+            destination = machine.guest.capability(:create_tmp_path, type: type, extension: extension)
+          end
+
+          if options[:compress]
+            compression_setup!(machine, options)
+            @env.ui.info(I18n.t("vagrant.commands.upload.compress",
+              source: source,
+              type: options[:compression_type]
+            ))
+            destination_decompressed = destination
+            destination = machine.guest.capability(:create_tmp_path, type: :file, extension: ".#{options[:compression_type]}")
+            source_display = source
+            source = options[:compression_type] == :zip ? compress_source_zip(source) : compress_source_tgz(source)
+          end
+
+          @env.ui.info(I18n.t("vagrant.commands.upload.start",
+            source: source,
+            destination: destination
+          ))
+
+          # If the source is a directory, attach a `/.` to the end so we
+          # upload the contents to the destination instead of within a
+          # folder at the destination
+          if File.directory?(source) && !source.end_with?(".")
+            upload_source = File.join(source, ".")
+          else
+            upload_source = source
+          end
+
+          machine.communicate.upload(upload_source, destination)
+
+          if options[:compress]
+            @env.ui.info(I18n.t("vagrant.commands.upload.decompress",
+              destination: destination_decompressed,
+              type: options[:compression_type]
+            ))
+            machine.guest.capability(options[:decompression_method], destination, destination_decompressed, type: type)
+            destination = destination_decompressed
+            FileUtils.rm(source)
+            source = source_display
+          end
+        end
+
+        @env.ui.info(I18n.t("vagrant.commands.upload.complete",
+          source: source,
+          destination: destination
+        ))
+
+        # Success, exit status 0
+        0
+      end
+
+      # Setup compression options and validate host and guest have capability
+      # to handle compression
+      #
+      # @param [Vagrant::Machine] machine Vagrant guest machine
+      # @param [Hash] options Command options
+      def compression_setup!(machine, options)
+        if !options[:compression_type]
+          if machine.guest.capability_host_chain.first[0] == :windows
+            options[:compression_type] = :zip
+          else
+            options[:compression_type] = :tgz
+          end
+        end
+        if !VALID_COMPRESS_TYPES.include?(options[:compression_type])
+          raise Vagrant::Errors::UploadInvalidCompressionType,
+            type: options[:compression_type],
+            valid_types: VALID_COMPRESS_TYPES.join(", ")
+        end
+        options[:decompression_method] = "decompress_#{options[:compression_type]}".to_sym
+        if !machine.guest.capability?(options[:decompression_method])
+          raise Vagrant::Errors::UploadMissingExtractCapability,
+            type: options[:compression_type]
+        end
+      end
+
+      # Compress path using zip into temporary file
+      #
+      # @param [String] path Path to compress
+      # @return [String] path to compressed file
+      def compress_source_zip(path)
+        require "zip"
+        zipfile = Tempfile.create(["vagrant", ".zip"])
+        zipfile.close
+        if File.file?(path)
+          source_items = [path]
+        else
+          source_items = Dir.glob(File.join(path, "**", "**", "*"))
+        end
+        c_dir = nil
+        Zip::File.open(zipfile.path, Zip::File::CREATE) do |zip|
+          source_items.each do |source_item|
+            next if File.directory?(source_item)
+            trim_item = source_item.sub(path, "").sub(%r{^[/\\]}, "")
+            dirname = File.dirname(trim_item)
+            zip.mkdir dirname if c_dir != dirname
+            c_dir = dirname
+            zip.get_output_stream(trim_item) do |f|
+              source_file = File.open(source_item, "rb")
+              while data = source_file.read(2048)
+                f.write(data)
+              end
+            end
+          end
+        end
+        zipfile.path
+      end
+
+      # Compress path using tar and gzip into temporary file
+      #
+      # @param [String] path Path to compress
+      # @return [String] path to compressed file
+      def compress_source_tgz(path)
+        tarfile = Tempfile.create(["vagrant", ".tar"])
+        tarfile.close
+        tarfile = File.open(tarfile.path, "wb+")
+        tgzfile = Tempfile.create(["vagrant", ".tgz"])
+        tgzfile.close
+        tgzfile = File.open(tgzfile.path, "wb")
+        tar = Gem::Package::TarWriter.new(tarfile)
+        tgz = Zlib::GzipWriter.new(tgzfile)
+        if File.file?(path)
+          tar.add_file(File.basename(path), File.stat(path).mode) do |io|
+            File.open(path, "rb") do |file|
+              while bytes = file.read(4096)
+                io.write(bytes)
+              end
+            end
+          end
+        else
+          Dir.glob(File.join(path, "**/**/*")).each do |item|
+            rel_path = item.sub(path, "")
+            item_mode = File.stat(item).mode
+
+            if File.directory?(item)
+              tar.mkdir(rel_path, item_mode)
+            else
+              tar.add_file(rel_path, item_mode) do |io|
+                File.open(item, "rb") do |file|
+                  while bytes = file.read(4096)
+                    io.write(bytes)
+                  end
+                end
+              end
+            end
+          end
+        end
+        tar.close
+        tarfile.rewind
+        while bytes = tarfile.read(4096)
+          tgz.write bytes
+        end
+        tgz.close
+        tgzfile.close
+        tarfile.close
+        File.delete(tarfile.path)
+        tgzfile.path
+      end
+    end
+  end
+end

data/plugins/commands/upload/plugin.rb

@@ -0,0 +1,17 @@
+require "vagrant"
+
+module VagrantPlugins
+  module CommandUpload
+    class Plugin < Vagrant.plugin("2")
+      name "upload command"
+      description <<-DESC
+      The `upload` command uploads files to guest via communicator
+      DESC
+
+      command("upload") do
+        require File.expand_path("../command", __FILE__)
+        Command
+      end
+    end
+  end
+end