vagrant-aws-mkubenka 0.7.2.pre.14 → 0.7.2.pre.16

data/vendor/bundle/ruby/2.3.0/bundler/gems/vagrant-5333e60e2d38/lib/vagrant/util/ssh.rb

@@ -1,205 +0,0 @@
-require "log4r"
-
-require 'childprocess'
-
-require "vagrant/util/file_mode"
-require "vagrant/util/platform"
-require "vagrant/util/safe_exec"
-require "vagrant/util/safe_puts"
-require "vagrant/util/subprocess"
-require "vagrant/util/which"
-
-module Vagrant
-  module Util
-    # This is a class that has helpers on it for dealing with SSH. These
-    # helpers don't depend on any part of Vagrant except what is given
-    # via the parameters.
-    class SSH
-      extend SafePuts
-
-      LOGGER = Log4r::Logger.new("vagrant::util::ssh")
-
-      # Checks that the permissions for a private key are valid, and fixes
-      # them if possible. SSH requires that permissions on the private key
-      # are 0600 on POSIX based systems. This will make a best effort to
-      # fix these permissions if they are not properly set.
-      #
-      # @param [Pathname] key_path The path to the private key.
-      def self.check_key_permissions(key_path)
-        # Don't do anything if we're on Windows, since Windows doesn't worry
-        # about key permissions.
-        return if Platform.windows? || Platform.wsl_windows_access_bypass?(key_path)
-
-        LOGGER.debug("Checking key permissions: #{key_path}")
-        stat = key_path.stat
-
-        if !stat.owned? && Process.uid != 0
-          # The SSH key must be owned by ourselves, unless we're root
-          raise Errors::SSHKeyBadOwner, key_path: key_path
-        end
-
-        if FileMode.from_octal(stat.mode) != "600"
-          LOGGER.info("Attempting to correct key permissions to 0600")
-          key_path.chmod(0600)
-
-          # Re-stat the file to get the new mode, and verify it worked
-          stat = key_path.stat
-          if FileMode.from_octal(stat.mode) != "600"
-            raise Errors::SSHKeyBadPermissions, key_path: key_path
-          end
-        end
-      rescue Errno::EPERM
-        # This shouldn't happen since we verify we own the file, but
-        # it is possible in theory, so we raise an error.
-        raise Errors::SSHKeyBadPermissions, key_path: key_path
-      end
-
-      # Halts the running of this process and replaces it with a full-fledged
-      # SSH shell into a remote machine.
-      #
-      # Note: This method NEVER returns. The process ends after this.
-      #
-      # @param [Hash] ssh_info This is the SSH information. For the keys
-      #   required please see the documentation of {Machine#ssh_info}.
-      # @param [Hash] opts These are additional options that are supported
-      #   by exec.
-      def self.exec(ssh_info, opts={})
-        # Ensure the platform supports ssh. On Windows there are several programs which
-        # include ssh, notably git, mingw and cygwin, but make sure ssh is in the path!
-        ssh_path = Which.which("ssh")
-        if !ssh_path
-          if Platform.windows?
-            raise Errors::SSHUnavailableWindows,
-              host: ssh_info[:host],
-              port: ssh_info[:port],
-              username: ssh_info[:username],
-              key_path: ssh_info[:private_key_path].join(", ")
-          end
-
-          raise Errors::SSHUnavailable
-        end
-
-        # On Windows, we need to detect whether SSH is actually "plink"
-        # underneath the covers. In this case, we tell the user.
-        if Platform.windows?
-          r = Subprocess.execute(ssh_path)
-          if r.stdout.include?("PuTTY Link") || r.stdout.include?("Plink: command-line connection utility")
-            raise Errors::SSHIsPuttyLink,
-              host: ssh_info[:host],
-              port: ssh_info[:port],
-              username: ssh_info[:username],
-              key_path: ssh_info[:private_key_path].join(", ")
-          end
-        end
-
-        # If plain mode is enabled then we don't do any authentication (we don't
-        # set a user or an identity file)
-        plain_mode = opts[:plain_mode]
-
-        options = {}
-        options[:host] = ssh_info[:host]
-        options[:port] = ssh_info[:port]
-        options[:username] = ssh_info[:username]
-        options[:private_key_path] = ssh_info[:private_key_path]
-
-        log_level = ssh_info[:log_level] || "FATAL"
-
-        # Command line options
-        command_options = [
-          "-p", options[:port].to_s,
-          "-o", "LogLevel=#{log_level}"]
-
-        if ssh_info[:compression]
-          command_options += ["-o", "Compression=yes"]
-        end
-
-        if ssh_info[:dsa_authentication]
-          command_options += ["-o", "DSAAuthentication=yes"]
-        end
-
-        # Solaris/OpenSolaris/Illumos uses SunSSH which doesn't support the
-        # IdentitiesOnly option. Also, we don't enable it in plain mode or if
-        # if keys_only is false so that SSH and Net::SSH properly search our identities
-        # and tries to do it itself.
-        if !Platform.solaris? && !plain_mode && ssh_info[:keys_only]
-          command_options += ["-o", "IdentitiesOnly=yes"]
-        end
-
-        # no strict hostkey checking unless paranoid
-        if ! ssh_info[:paranoid]
-          command_options += [
-            "-o", "StrictHostKeyChecking=no",
-            "-o", "UserKnownHostsFile=/dev/null"]
-        end
-
-        # If we're not in plain mode and :private_key_path is set attach the private key path(s).
-        if !plain_mode && options[:private_key_path]
-          options[:private_key_path].each do |path|
-            command_options += ["-i", path.to_s]
-          end
-        end
-
-        if ssh_info[:forward_x11]
-          # Both are required so that no warnings are shown regarding X11
-          command_options += [
-            "-o", "ForwardX11=yes",
-            "-o", "ForwardX11Trusted=yes"]
-        end
-
-        if ssh_info[:proxy_command]
-          command_options += ["-o", "ProxyCommand=#{ssh_info[:proxy_command]}"]
-        end
-
-        if ssh_info[:forward_env]
-          command_options += ["-o", "SendEnv=#{ssh_info[:forward_env].join(" ")}"]
-        end
-
-        # Configurables -- extra_args should always be last due to the way the
-        # ssh args parser works. e.g. if the user wants to use the -t option,
-        # any shell command(s) she'd like to run on the remote server would
-        # have to be the last part of the 'ssh' command:
-        #
-        #   $ ssh localhost -t -p 2222 "cd mydirectory; bash"
-        #
-        # Without having extra_args be last, the user loses this ability
-        command_options += ["-o", "ForwardAgent=yes"] if ssh_info[:forward_agent]
-        command_options.concat(opts[:extra_args]) if opts[:extra_args]
-
-        # Build up the host string for connecting
-        host_string = options[:host]
-        host_string = "#{options[:username]}@#{host_string}" if !plain_mode
-        command_options.unshift(host_string)
-
-        # On Cygwin we want to get rid of any DOS file warnings because
-        # we really don't care since both work.
-        ENV["nodosfilewarning"] = "1" if Platform.cygwin?
-
-        ssh = ssh_info[:ssh_command] || 'ssh'
-
-        # Invoke SSH with all our options
-        if !opts[:subprocess]
-          LOGGER.info("Invoking SSH: #{ssh} #{command_options.inspect}")
-          SafeExec.exec(ssh, *command_options)
-          return
-        end
-
-        # If we're still here, it means we're supposed to subprocess
-        # out to ssh rather than exec it.
-        LOGGER.info("Executing SSH in subprocess: #{ssh} #{command_options.inspect}")
-        process = ChildProcess.build(ssh, *command_options)
-        process.io.inherit!
-
-        # Forward configured environment variables.
-        if ssh_info[:forward_env]
-          ssh_info[:forward_env].each do |key|
-            process.environment[key] = ENV[key]
-          end
-        end
-
-        process.start
-        process.wait
-        return process.exit_code
-      end
-    end
-  end
-end

data/vendor/bundle/ruby/2.3.0/bundler/gems/vagrant-5333e60e2d38/plugins/commands/box/command/add.rb

@@ -1,101 +0,0 @@
-require 'optparse'
-
-require_relative 'download_mixins'
-
-module VagrantPlugins
-  module CommandBox
-    module Command
-      class Add < Vagrant.plugin("2", :command)
-        include DownloadMixins
-
-        def execute
-          options = {}
-
-          opts = OptionParser.new do |o|
-            o.banner = "Usage: vagrant box add [options] <name, url, or path>"
-            o.separator ""
-            o.separator "Options:"
-            o.separator ""
-
-            o.on("-c", "--clean", "Clean any temporary download files") do |c|
-              options[:clean] = c
-            end
-
-            o.on("-f", "--force", "Overwrite an existing box if it exists") do |f|
-              options[:force] = f
-            end
-
-            build_download_options(o, options)
-
-            o.on("--location-trusted", "Trust 'Location' header from HTTP redirects and use the same credentials for subsequent urls as for the initial one") do |l|
-                options[:location_trusted] = l
-            end
-
-            o.on("--provider PROVIDER", String, "Provider the box should satisfy") do |p|
-              options[:provider] = p
-            end
-
-            o.on("--box-version VERSION", String, "Constrain version of the added box") do |v|
-              options[:version] = v
-            end
-
-            o.separator ""
-            o.separator "The box descriptor can be the name of a box on HashiCorp's Atlas,"
-            o.separator "or a URL, or a local .box file, or a local .json file containing"
-            o.separator "the catalog metadata."
-            o.separator ""
-            o.separator "The options below only apply if you're adding a box file directly,"
-            o.separator "and not using a Vagrant server or a box structured like 'user/box':"
-            o.separator ""
-
-            o.on("--checksum CHECKSUM", String, "Checksum for the box") do |c|
-              options[:checksum] = c
-            end
-
-            o.on("--checksum-type TYPE", String, "Checksum type (md5, sha1, sha256)") do |c|
-              options[:checksum_type] = c.to_sym
-            end
-
-            o.on("--name BOX", String, "Name of the box") do |n|
-              options[:name] = n
-            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
-
-          url = argv[0]
-          if argv.length == 2
-            options[:name] = argv[0]
-            url = argv[1]
-          end
-
-          @env.action_runner.run(Vagrant::Action.action_box_add, {
-            box_url: url,
-            box_name: options[:name],
-            box_provider: options[:provider],
-            box_version: options[:version],
-            box_checksum_type: options[:checksum_type],
-            box_checksum: options[:checksum],
-            box_clean: options[:clean],
-            box_force: options[:force],
-            box_download_ca_cert: options[:ca_cert],
-            box_download_ca_path: options[:ca_path],
-            box_client_cert: options[:client_cert],
-            box_download_insecure: options[:insecure],
-            box_download_location_trusted: options[:location_trusted],
-            ui: Vagrant::UI::Prefixed.new(@env.ui, "box"),
-          })
-
-          # Success, exit status 0
-          0
-        end
-      end
-    end
-  end
-end

data/vendor/bundle/ruby/2.3.0/bundler/gems/vagrant-5333e60e2d38/plugins/commands/box/command/update.rb

@@ -1,161 +0,0 @@
-require 'optparse'
-
-require_relative 'download_mixins'
-
-module VagrantPlugins
-  module CommandBox
-    module Command
-      class Update < Vagrant.plugin("2", :command)
-        include DownloadMixins
-
-        def execute
-          options = {}
-          download_options = {}
-
-          opts = OptionParser.new do |o|
-            o.banner = "Usage: vagrant box update [options]"
-            o.separator ""
-            o.separator "Updates the box that is in use in the current Vagrant environment,"
-            o.separator "if there any updates available. This does not destroy/recreate the"
-            o.separator "machine, so you'll have to do that to see changes."
-            o.separator ""
-            o.separator "To update a specific box (not tied to a Vagrant environment), use the"
-            o.separator "--box flag."
-            o.separator ""
-            o.separator "Options:"
-            o.separator ""
-
-            o.on("--box BOX", String, "Update a specific box") do |b|
-              options[:box] = b
-            end
-
-            o.on("--provider PROVIDER", String, "Update box with specific provider") do |p|
-              options[:provider] = p.to_sym
-            end
-
-            build_download_options(o, download_options)
-          end
-
-          argv = parse_options(opts)
-          return if !argv
-
-          if options[:box]
-            update_specific(options[:box], options[:provider], download_options)
-          else
-            update_vms(argv, options[:provider], download_options)
-          end
-
-          0
-        end
-
-        def update_specific(name, provider, download_options)
-          boxes = {}
-          @env.boxes.all.each do |n, v, p|
-            boxes[n] ||= {}
-            boxes[n][p] ||= []
-            boxes[n][p] << v
-          end
-
-          if !boxes[name]
-            raise Vagrant::Errors::BoxNotFound, name: name.to_s
-          end
-
-          if !provider
-            if boxes[name].length > 1
-              raise Vagrant::Errors::BoxUpdateMultiProvider,
-                name: name.to_s,
-                providers: boxes[name].keys.map(&:to_s).sort.join(", ")
-            end
-
-            provider = boxes[name].keys.first
-          elsif !boxes[name][provider]
-            raise Vagrant::Errors::BoxNotFoundWithProvider,
-              name: name.to_s,
-              provider: provider.to_s,
-              providers: boxes[name].keys.map(&:to_s).sort.join(", ")
-          end
-
-          to_update = [
-            [name, provider, boxes[name][provider].sort.last],
-          ]
-
-          to_update.each do |n, p, v|
-            box = @env.boxes.find(n, p, v)
-            box_update(box, "> #{v}", @env.ui, download_options)
-          end
-        end
-
-        def update_vms(argv, provider, download_options)
-          machines = {}
-
-          with_target_vms(argv, provider: provider) do |machine|
-            if !machine.config.vm.box
-              machine.ui.output(I18n.t(
-                "vagrant.errors.box_update_no_name"))
-              next
-            end
-
-            if !machine.box
-              machine.ui.output(I18n.t(
-                "vagrant.errors.box_update_no_box",
-                name: machine.config.vm.box))
-              next
-            end
-
-            name     = machine.box.name
-            provider = machine.box.provider
-            version  = machine.config.vm.box_version || machine.box.version
-
-            machines["#{name}_#{provider}_#{version}"] = machine
-          end
-
-          machines.each do |_, machine|
-            box = machine.box
-            version = machine.config.vm.box_version
-            # Get download options from machine configuration if not specified
-            # on the command line.
-            download_options[:ca_cert] ||= machine.config.vm.box_download_ca_cert
-            download_options[:ca_path] ||= machine.config.vm.box_download_ca_path
-            download_options[:client_cert] ||= machine.config.vm.box_download_client_cert
-            if download_options[:insecure].nil?
-              download_options[:insecure] = machine.config.vm.box_download_insecure
-            end
-            box_update(box, version, machine.ui, download_options)
-          end
-        end
-
-        def box_update(box, version, ui, download_options)
-          ui.output(I18n.t("vagrant.box_update_checking", name: box.name))
-          ui.detail("Latest installed version: #{box.version}")
-          ui.detail("Version constraints: #{version}")
-          ui.detail("Provider: #{box.provider}")
-
-          update = box.has_update?(version, download_options: download_options)
-          if !update
-            ui.success(I18n.t(
-              "vagrant.box_up_to_date_single",
-              name: box.name, version: box.version))
-            return
-          end
-
-          ui.output(I18n.t(
-            "vagrant.box_updating",
-            name: update[0].name,
-            provider: update[2].name,
-            old: box.version,
-            new: update[1].version))
-          @env.action_runner.run(Vagrant::Action.action_box_add, {
-            box_url: box.metadata_url,
-            box_provider: update[2].name,
-            box_version: update[1].version,
-            ui: ui,
-            box_client_cert: download_options[:client_cert],
-            box_download_ca_cert: download_options[:ca_cert],
-            box_download_ca_path: download_options[:ca_path],
-            box_download_insecure: download_options[:insecure]
-          })
-        end
-      end
-    end
-  end
-end

data/vendor/bundle/ruby/2.3.0/bundler/gems/vagrant-5333e60e2d38/plugins/commands/login/client.rb

@@ -1,151 +0,0 @@
-require "rest_client"
-require "vagrant/util/downloader"
-require "vagrant/util/presence"
-
-module VagrantPlugins
-  module LoginCommand
-    class Client
-      include Vagrant::Util::Presence
-
-      # Initializes a login client with the given Vagrant::Environment.
-      #
-      # @param [Vagrant::Environment] env
-      def initialize(env)
-        @logger = Log4r::Logger.new("vagrant::login::client")
-        @env    = env
-      end
-
-      # Removes the token, effectively logging the user out.
-      def clear_token
-        @logger.info("Clearing token")
-        token_path.delete if token_path.file?
-      end
-
-      # Checks if the user is logged in by verifying their authentication
-      # token.
-      #
-      # @return [Boolean]
-      def logged_in?
-        token = self.token
-        return false if !token
-
-        with_error_handling do
-          url = "#{Vagrant.server_url}/api/v1/authenticate" +
-            "?access_token=#{token}"
-          RestClient.get(url, content_type: :json)
-          true
-        end
-      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] user
-      # @param [String] pass
-      # @return [String] token The access token, or nil if auth failed.
-      def login(user, pass)
-        @logger.info("Logging in '#{user}'")
-
-        with_error_handling do
-          url      = "#{Vagrant.server_url}/api/v1/authenticate"
-          request  = { "user" => { "login" => user, "password" => pass } }
-
-          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(request),
-            proxy: proxy,
-            headers: {
-              accept: :json,
-              content_type: :json,
-              user_agent: Vagrant::Util::Downloader::USER_AGENT,
-            },
-          )
-
-          data = JSON.load(response.to_s)
-          data["token"]
-        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
-      # `ATLAS_TOKEN` environment variable and then fallback to the stored
-      # access token on disk.
-      #
-      # @return [String]
-      def token
-        if present?(ENV["ATLAS_TOKEN"]) && token_path.exist?
-          @env.ui.warn <<-EOH.strip
-Vagrant detected both the ATLAS_TOKEN environment variable and a Vagrant login
-token are present on this system. The ATLAS_TOKEN environment variable takes
-precedence over the locally stored token. To remove this error, either unset
-the ATLAS_TOKEN environment variable or remove the login token stored on disk:
-
-    ~/.vagrant.d/data/vagrant_login_token
-
-In general, the ATLAS_TOKEN is more preferred because it is respected by all
-HashiCorp products.
-EOH
-        end
-
-        if present?(ENV["ATLAS_TOKEN"])
-          @logger.debug("Using authentication token from environment variable")
-          return ENV["ATLAS_TOKEN"]
-        end
-
-        if token_path.exist?
-          @logger.debug("Using authentication token from disk at #{token_path}")
-          return token_path.read.strip
-        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!")
-        false
-      rescue RestClient::NotAcceptable => e
-        @logger.debug("Got unacceptable response:")
-        @logger.debug(e.message)
-        @logger.debug(e.backtrace.join("\n"))
-
-        begin
-          errors = JSON.parse(e.response)["errors"].join("\n")
-          raise Errors::ServerError, errors: errors
-        rescue JSON::ParserError; end
-
-        raise "An unexpected error occurred: #{e.inspect}"
-      rescue SocketError
-        @logger.info("Socket error")
-        raise Errors::ServerUnreachable, url: Vagrant.server_url.to_s
-      end
-
-      def token_path
-        @env.data_dir.join("vagrant_login_token")
-      end
-    end
-  end
-end