vagrant-aws-detiber 0.7.2.pre.2

data/vendor/bundle/ruby/2.3.0/bundler/gems/vagrant-419afb4dcffe/lib/vagrant/util/command_deprecation.rb

@@ -0,0 +1,56 @@
+module Vagrant
+  module Util
+    # Automatically add deprecation notices to commands
+    module CommandDeprecation
+
+      # @return [String] generated name of command
+      def deprecation_command_name
+        name_parts = self.class.name.split("::")
+        [
+          name_parts[1].sub('Command', ''),
+          name_parts[3]
+        ].compact.map(&:downcase).join(" ")
+      end
+
+      def self.included(klass)
+        klass.class_eval do
+          class << self
+            if method_defined?(:synopsis)
+              alias_method :non_deprecated_synopsis, :synopsis
+
+              def synopsis
+                if !non_deprecated_synopsis.to_s.empty?
+                  "#{non_deprecated_synopsis} [DEPRECATED]"
+                else
+                  non_deprecated_synopsis
+                end
+              end
+            end
+          end
+          alias_method :non_deprecated_execute, :execute
+
+          def execute(*args, &block)
+            @env[:ui].warn(I18n.t("vagrant.commands.deprecated",
+              name: deprecation_command_name
+            ) + "\n")
+            non_deprecated_execute(*args, &block)
+          end
+        end
+      end
+
+      # Mark command deprecation complete and fully disable
+      # the command's functionality
+      module Complete
+        def self.included(klass)
+          klass.include(CommandDeprecation)
+          klass.class_eval do
+            def execute(*_)
+              raise Vagrant::Errors::CommandDeprecated,
+                name: deprecation_command_name
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/vendor/bundle/ruby/2.3.0/bundler/gems/vagrant-419afb4dcffe/lib/vagrant/util/counter.rb

@@ -0,0 +1,24 @@
+require 'thread'
+
+module Vagrant
+  module Util
+    # Atomic counter implementation. This is useful for incrementing
+    # a counter which is guaranteed to only be used once in its class.
+    module Counter
+      def get_and_update_counter(name=nil)
+        name ||= :global
+
+        mutex.synchronize do
+          @__counter ||= Hash.new(1)
+          result = @__counter[name]
+          @__counter[name] += 1
+          result
+        end
+      end
+
+      def mutex
+        @__counter_mutex ||= Mutex.new
+      end
+    end
+  end
+end

data/vendor/bundle/ruby/2.3.0/bundler/gems/vagrant-419afb4dcffe/lib/vagrant/util/credential_scrubber.rb

@@ -0,0 +1,71 @@
+module Vagrant
+  module Util
+    # Utility class to remove credential information from strings
+    class CredentialScrubber
+      # String used to replace credential information
+      REPLACEMENT_TEXT = "*****".freeze
+
+      # Attempt to remove detected credentials from string
+      #
+      # @param [String] string
+      # @return [String]
+      def self.scrub(string)
+        string = url_scrubber(string)
+      end
+
+      # Detect URLs and remove any embedded credentials
+      #
+      # @param [String] string
+      # @return [String]
+      def self.url_scrubber(string)
+        string.gsub(%r{(ftp|https?)://[^\s]+@[^\s]+}) do |address|
+          uri = URI.parse(address)
+          uri.user = uri.password = REPLACEMENT_TEXT
+          uri.to_s
+        end
+      end
+
+      # Remove sensitive information from string
+      #
+      # @param [String] string
+      # @return [String]
+      def self.desensitize(string)
+        string = string.to_s.dup
+        sensitive_strings.each do |remove|
+          string.gsub!(remove, REPLACEMENT_TEXT)
+        end
+        string
+      end
+
+      # Register a sensitive string to be scrubbed
+      def self.sensitive(string)
+        string = string.to_s.dup
+        if string.length > 0
+          sensitive_strings.push(string).uniq!
+        end
+        nil
+      end
+
+      # Deregister a sensitive string and allow output
+      def self.unsensitive(string)
+        sensitive_strings.delete(string)
+        nil
+      end
+
+      # @return [Array<string>]
+      def self.sensitive_strings
+        if !defined?(@_sensitive_strings)
+          @_sensitive_strings = []
+        end
+        @_sensitive_strings
+      end
+
+      # @private
+      # Reset the cached values for scrubber. This is not considered a public
+      # API and should only be used for testing.
+      def self.reset!
+        instance_variables.each(&method(:remove_instance_variable))
+      end
+    end
+  end
+end

data/vendor/bundle/ruby/2.3.0/bundler/gems/vagrant-419afb4dcffe/lib/vagrant/util/deep_merge.rb

@@ -0,0 +1,20 @@
+module Vagrant
+  module Util
+    module DeepMerge
+      # This was lifted straight from Rails 4.0.2 as a basic Hash
+      # deep merge.
+      def self.deep_merge(myself, other_hash, &block)
+        myself = myself.dup
+        other_hash.each_pair do |k,v|
+          tv = myself[k]
+          if tv.is_a?(Hash) && v.is_a?(Hash)
+            myself[k] = deep_merge(tv, v, &block)
+          else
+            myself[k] = block && tv ? block.call(k, tv, v) : v
+          end
+        end
+        myself
+      end
+    end
+  end
+end

data/vendor/bundle/ruby/2.3.0/bundler/gems/vagrant-419afb4dcffe/lib/vagrant/util/downloader.rb

@@ -0,0 +1,345 @@
+require "uri"
+
+require "log4r"
+require "digest/md5"
+require "digest/sha1"
+require "vagrant/util/busy"
+require "vagrant/util/platform"
+require "vagrant/util/subprocess"
+
+module Vagrant
+  module Util
+    # This class downloads files using various protocols by subprocessing
+    # to cURL. cURL is a much more capable and complete download tool than
+    # a hand-rolled Ruby library, so we defer to its expertise.
+    class Downloader
+      # Custom user agent provided to cURL so that requests to URL shorteners
+      # are properly tracked.
+      #
+      #     Vagrant/1.7.4 (+https://www.vagrantup.com; ruby2.1.0)
+      USER_AGENT = "Vagrant/#{VERSION} (+https://www.vagrantup.com; #{RUBY_ENGINE}#{RUBY_VERSION})".freeze
+
+      # Supported file checksum
+      CHECKSUM_MAP = {
+        :md5 => Digest::MD5,
+        :sha1 => Digest::SHA1
+      }.freeze
+
+      # Hosts that do not require notification on redirect
+      SILENCED_HOSTS = [
+        "vagrantcloud.com".freeze,
+        "vagrantup.com".freeze
+      ].freeze
+
+      attr_reader :source
+      attr_reader :destination
+
+      def initialize(source, destination, options=nil)
+        options     ||= {}
+
+        @logger      = Log4r::Logger.new("vagrant::util::downloader")
+        @source      = source.to_s
+        @destination = destination.to_s
+
+        begin
+          url = URI.parse(@source)
+          if url.scheme && url.scheme.start_with?("http") && url.user
+            auth = "#{URI.unescape(url.user)}"
+            auth += ":#{URI.unescape(url.password)}" if url.password
+            url.user = nil
+            url.password = nil
+            options[:auth] ||= auth
+            @source = url.to_s
+          end
+        rescue URI::InvalidURIError
+          # Ignore, since its clearly not HTTP
+        end
+
+        # Get the various optional values
+        @auth        = options[:auth]
+        @ca_cert     = options[:ca_cert]
+        @ca_path     = options[:ca_path]
+        @continue    = options[:continue]
+        @headers     = options[:headers]
+        @insecure    = options[:insecure]
+        @ui          = options[:ui]
+        @client_cert = options[:client_cert]
+        @location_trusted = options[:location_trusted]
+        @checksums   = {
+          :md5 => options[:md5],
+          :sha1 => options[:sha1]
+        }
+      end
+
+      # This executes the actual download, downloading the source file
+      # to the destination with the given options used to initialize this
+      # class.
+      #
+      # If this method returns without an exception, the download
+      # succeeded. An exception will be raised if the download failed.
+      def download!
+        # This variable can contain the proc that'll be sent to
+        # the subprocess execute.
+        data_proc = nil
+
+        extra_subprocess_opts = {}
+        if @ui
+          # If we're outputting progress, then setup the subprocess to
+          # tell us output so we can parse it out.
+          extra_subprocess_opts[:notify] = :stderr
+
+          progress_data = ""
+          progress_regexp = /^\r\s*(\d.+?)\r/m
+
+          # Setup the proc that'll receive the real-time data from
+          # the downloader.
+          data_proc = Proc.new do |type, data|
+            # Type will always be "stderr" because that is the only
+            # type of data we're subscribed for notifications.
+
+            # Accumulate progress_data
+            progress_data << data
+
+            while true
+              # If the download has been redirected and we are no longer downloading
+              # from the original host, notify the user that the target host has
+              # changed from the source.
+              if progress_data.include?("Location")
+                location = progress_data.scan(/Location: (.+?)$/m).flatten.compact.first.to_s.strip
+                if !location.empty?
+                  @logger.info("download redirected to #{location}")
+                  location_uri = URI.parse(location)
+                  source_uri = URI.parse(source)
+                  source_host = source_uri.host.split(".", 2).last
+                  location_host = location_uri.host.split(".", 2).last
+                  if !@redirect_notify && location_host != source_host && !SILENCED_HOSTS.include?(location_host)
+                    @ui.clear_line
+                    @ui.detail "Download redirected to host: #{location_uri.host}"
+                  end
+                  @redirect_notify = true
+                end
+                progress_data.replace("")
+                break
+              end
+
+              # If we have a full amount of column data (two "\r") then
+              # we report new progress reports. Otherwise, just keep
+              # accumulating.
+              match = nil
+              check_match = true
+
+              while check_match
+                check_match = progress_regexp.match(progress_data)
+                if check_match
+                  data = check_match[1].to_s
+                  stop = progress_data.index(data) + data.length
+                  progress_data.slice!(0, stop)
+
+                  match = check_match
+                end
+              end
+
+              break if !match
+
+              # Ignore the first \r and split by whitespace to grab the columns
+              columns = data.strip.split(/\s+/)
+
+              # COLUMN DATA:
+              #
+              # 0 - % total
+              # 1 - Total size
+              # 2 - % received
+              # 3 - Received size
+              # 4 - % transferred
+              # 5 - Transferred size
+              # 6 - Average download speed
+              # 7 - Average upload speed
+              # 9 - Total time
+              # 9 - Time spent
+              # 10 - Time left
+              # 11 - Current speed
+
+              output = "Progress: #{columns[0]}% (Rate: #{columns[11]}/s, Estimated time remaining: #{columns[10]})"
+              @ui.clear_line
+              @ui.detail(output, new_line: false)
+            end
+          end
+        end
+
+        @logger.info("Downloader starting download: ")
+        @logger.info("  -- Source: #{@source}")
+        @logger.info("  -- Destination: #{@destination}")
+
+        retried = false
+        begin
+          # Get the command line args and the subprocess opts based
+          # on our downloader settings.
+          options, subprocess_options = self.options
+          options += ["--output", @destination]
+          options << @source
+
+          # Merge in any extra options we set
+          subprocess_options.merge!(extra_subprocess_opts)
+
+          # Go!
+          execute_curl(options, subprocess_options, &data_proc)
+        rescue Errors::DownloaderError => e
+          # If we already retried, raise it.
+          raise if retried
+
+          @logger.error("Exit code: #{e.extra_data[:code]}")
+
+          # If its any error other than 33, it is an error.
+          raise if e.extra_data[:code].to_i != 33
+
+          # Exit code 33 means that the server doesn't support ranges.
+          # In this case, try again without resume.
+          @logger.error("Error is server doesn't support byte ranges. Retrying from scratch.")
+          @continue = false
+          retried = true
+          retry
+        ensure
+          # If we're outputting to the UI, clear the output to
+          # avoid lingering progress meters.
+          if @ui
+            @ui.clear_line
+
+            # Windows doesn't clear properly for some reason, so we just
+            # output one more newline.
+            @ui.detail("") if Platform.windows?
+          end
+        end
+
+        validate_download!(@source, @destination, @checksums)
+
+        # Everything succeeded
+        true
+      end
+
+      # Does a HEAD request of the URL and returns the output.
+      def head
+        options, subprocess_options = self.options
+        options.unshift("-I")
+        options << @source
+
+        @logger.info("HEAD: #{@source}")
+        result = execute_curl(options, subprocess_options)
+        result.stdout
+      end
+
+      protected
+
+      # Apply any checksum validations based on provided
+      # options content
+      #
+      # @param source [String] Source of file
+      # @param path [String, Pathname] local file path
+      # @param checksums [Hash] User provided options
+      # @option checksums [String] :md5 Compare MD5 checksum
+      # @option checksums [String] :sha1 Compare SHA1 checksum
+      # @return [Boolean]
+      def validate_download!(source, path, checksums)
+        CHECKSUM_MAP.each do |type, klass|
+          if checksums[type]
+            result = checksum_file(klass, path)
+            @logger.debug("Validating checksum (#{type}) for #{source}. " \
+              "expected: #{checksums[type]} actual: #{result}")
+            if checksums[type] != result
+              raise Errors::DownloaderChecksumError.new(
+                source: source,
+                path: path,
+                type: type,
+                expected_checksum: checksums[type],
+                actual_checksum: result
+              )
+            end
+          end
+        end
+        true
+      end
+
+      # Generate checksum on given file
+      #
+      # @param digest_class [Class] Digest class to use for generating checksum
+      # @param path [String, Pathname] Path to file
+      # @return [String] hexdigest result
+      def checksum_file(digest_class, path)
+        digester = digest_class.new
+        digester.file(path)
+        digester.hexdigest
+      end
+
+      def execute_curl(options, subprocess_options, &data_proc)
+        options = options.dup
+        options << subprocess_options
+
+        # Create the callback that is called if we are interrupted
+        interrupted  = false
+        int_callback = Proc.new do
+          @logger.info("Downloader interrupted!")
+          interrupted = true
+        end
+
+        # Execute!
+        result = Busy.busy(int_callback) do
+          Subprocess.execute("curl", *options, &data_proc)
+        end
+
+        # If the download was interrupted, then raise a specific error
+        raise Errors::DownloaderInterrupted if interrupted
+
+        # If it didn't exit successfully, we need to parse the data and
+        # show an error message.
+        if result.exit_code != 0
+          @logger.warn("Downloader exit code: #{result.exit_code}")
+          parts    = result.stderr.split(/\n*curl:\s+\(\d+\)\s*/, 2)
+          parts[1] ||= ""
+          raise Errors::DownloaderError,
+            code: result.exit_code,
+            message: parts[1].chomp
+        end
+
+        result
+      end
+
+      # Returns the varoius cURL and subprocess options.
+      #
+      # @return [Array<Array, Hash>]
+      def options
+        # Build the list of parameters to execute with cURL
+        options = [
+          "-q",
+          "--fail",
+          "--location",
+          "--max-redirs", "10", "--verbose",
+          "--user-agent", USER_AGENT,
+        ]
+
+        options += ["--cacert", @ca_cert] if @ca_cert
+        options += ["--capath", @ca_path] if @ca_path
+        options += ["--continue-at", "-"] if @continue
+        options << "--insecure" if @insecure
+        options << "--cert" << @client_cert if @client_cert
+        options << "-u" << @auth if @auth
+        options << "--location-trusted" if @location_trusted
+
+        if @headers
+          Array(@headers).each do |header|
+            options << "-H" << header
+          end
+        end
+
+        # Specify some options for the subprocess
+        subprocess_options = {}
+
+        # If we're in Vagrant, then we use the packaged CA bundle
+        if Vagrant.in_installer?
+          subprocess_options[:env] ||= {}
+          subprocess_options[:env]["CURL_CA_BUNDLE"] = ENV["CURL_CA_BUNDLE"]
+        end
+
+        return [options, subprocess_options]
+      end
+    end
+  end
+end

data/vendor/bundle/ruby/2.3.0/bundler/gems/vagrant-419afb4dcffe/lib/vagrant/util/env.rb

@@ -0,0 +1,53 @@
+module Vagrant
+  module Util
+    class Env
+      def self.with_original_env
+        original_env = ENV.to_hash
+        if defined?(::Bundler) && defined?(::Bundler::ORIGINAL_ENV)
+          ENV.replace(::Bundler::ORIGINAL_ENV)
+        end
+        ENV.update(Vagrant.original_env)
+        yield
+      ensure
+        ENV.replace(original_env.to_hash)
+      end
+
+      # Execute the given command, removing any Ruby-specific environment
+      # variables. This is an "enhanced" version of `Bundler.with_clean_env`,
+      # which only removes Bundler-specific values. We need to remove all
+      # values, specifically:
+      #
+      # - _ORIGINAL_GEM_PATH
+      # - GEM_PATH
+      # - GEM_HOME
+      # - GEM_ROOT
+      # - BUNDLE_BIN_PATH
+      # - BUNDLE_GEMFILE
+      # - RUBYLIB
+      # - RUBYOPT
+      # - RUBY_ENGINE
+      # - RUBY_ROOT
+      # - RUBY_VERSION
+      #
+      # This will escape Vagrant's environment entirely, which is required if
+      # calling an executable that lives in another Ruby environment. The
+      # original environment restored at the end of this call.
+      #
+      # @param [Proc] block
+      #   the block to execute with the cleaned environment
+      def self.with_clean_env
+        with_original_env do
+          if ENV["BUNDLE_ORIG_MANPATH"]
+            ENV["MANPATH"] = ENV["BUNDLE_ORIG_MANPATH"]
+          end
+          ENV.delete_if { |k,_| k[0,7] == "BUNDLE_" }
+          if ENV.has_key? "RUBYOPT"
+            ENV["RUBYOPT"] = ENV["RUBYOPT"].sub("-rbundler/setup", "")
+            ENV["RUBYOPT"] = ENV["RUBYOPT"].sub("-I#{File.expand_path('..', __FILE__)}", "")
+          end
+          yield
+        end
+      end
+    end
+  end
+end

data/vendor/bundle/ruby/2.3.0/bundler/gems/vagrant-419afb4dcffe/lib/vagrant/util/file_checksum.rb

@@ -0,0 +1,45 @@
+# This is an "interface" that should be implemented by any digest class
+# passed into FileChecksum. Note that this isn't strictly enforced at
+# the moment, and this class isn't directly used. It is merely here for
+# documentation of structure of the class.
+class DigestClass
+  def update(string); end
+  def hexdigest; end
+end
+
+class FileChecksum
+  BUFFER_SIZE = 1024 * 8
+
+  # Initializes an object to calculate the checksum of a file. The given
+  # ``digest_klass`` should implement the ``DigestClass`` interface. Note
+  # that the built-in Ruby digest classes duck type this properly:
+  # Digest::MD5, Digest::SHA1, etc.
+  def initialize(path, digest_klass)
+    @digest_klass = digest_klass
+    @path         = path
+  end
+
+  # This calculates the checksum of the file and returns it as a
+  # string.
+  #
+  # @return [String]
+  def checksum
+    digest = @digest_klass.new
+    buf = ''
+
+    File.open(@path, "rb") do |f|
+      while !f.eof
+        begin
+          f.readpartial(BUFFER_SIZE, buf)
+          digest.update(buf)
+        rescue EOFError
+          # Although we check for EOF earlier, this seems to happen
+          # sometimes anyways [GH-2716].
+          break
+        end
+      end
+    end
+
+    return digest.hexdigest
+  end
+end

data/vendor/bundle/ruby/2.3.0/bundler/gems/vagrant-419afb4dcffe/lib/vagrant/util/file_mode.rb

@@ -0,0 +1,12 @@
+module Vagrant
+  module Util
+    class FileMode
+      # This returns the file permissions as a string from
+      # an octal number.
+      def self.from_octal(octal)
+        perms = sprintf("%o", octal)
+        perms.reverse[0..2].reverse
+      end
+    end
+  end
+end

data/vendor/bundle/ruby/2.3.0/bundler/gems/vagrant-419afb4dcffe/lib/vagrant/util/guest_inspection.rb

@@ -0,0 +1,63 @@
+module Vagrant
+  module Util
+    # Helper methods for inspecting guests to determine if specific services
+    # or applications are installed and in use
+    module GuestInspection
+      # Linux specific inspection helpers
+      module Linux
+
+        ## systemd helpers
+
+        # systemd is in use
+        #
+        # @return [Boolean]
+        def systemd?(comm)
+          comm.test("ps -o comm= 1 | grep systemd")
+        end
+
+        # systemd-networkd.service is in use
+        #
+        # @return [Boolean]
+        def systemd_networkd?(comm)
+          comm.test("sudo systemctl status systemd-networkd.service")
+        end
+
+        # systemd hostname set is via hostnamectl
+        #
+        # @return [Boolean]
+        def hostnamectl?(comm)
+          comm.test("hostnamectl")
+        end
+
+        ## netplan helpers
+
+        # netplan is installed
+        #
+        # @return [Boolean]
+        def netplan?(comm)
+          comm.test("netplan -h")
+        end
+
+        ## nmcli helpers
+
+        # nmcli is installed
+        #
+        # @return [Boolean]
+        def nmcli?(comm)
+          comm.test("nmcli")
+        end
+
+        # NetworkManager currently controls device
+        #
+        # @param comm [Communicator]
+        # @param device_name [String]
+        # @return [Boolean]
+        def nm_controlled?(comm, device_name)
+          comm.test("nmcli d show #{device_name}") &&
+            !comm.test("nmcli d show #{device_name} | grep unmanaged")
+        end
+
+      end
+    end
+  end
+end