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/plugin/manager.rb

@@ -1,185 +0,0 @@
-require "pathname"
-require "set"
-
-require_relative "../bundler"
-require_relative "../shared_helpers"
-require_relative "state_file"
-
-module Vagrant
-  module Plugin
-    # The Manager helps with installing, listing, and initializing plugins.
-    class Manager
-      # Returns the path to the [StateFile] for user plugins.
-      #
-      # @return [Pathname]
-      def self.user_plugins_file
-        Vagrant.user_data_path.join("plugins.json")
-      end
-
-      # Returns the path to the [StateFile] for system plugins.
-      def self.system_plugins_file
-        dir = Vagrant.installer_embedded_dir
-        return nil if !dir
-        Pathname.new(dir).join("plugins.json")
-      end
-
-      def self.instance
-        @instance ||= self.new(user_plugins_file)
-      end
-
-      # @param [Pathname] user_file
-      def initialize(user_file)
-        @user_file   = StateFile.new(user_file)
-
-        system_path  = self.class.system_plugins_file
-        @system_file = nil
-        @system_file = StateFile.new(system_path) if system_path && system_path.file?
-      end
-
-      # Installs another plugin into our gem directory.
-      #
-      # @param [String] name Name of the plugin (gem)
-      # @return [Gem::Specification]
-      def install_plugin(name, **opts)
-        local = false
-        if name =~ /\.gem$/
-          # If this is a gem file, then we install that gem locally.
-          local_spec = Vagrant::Bundler.instance.install_local(name, opts)
-          name       = local_spec.name
-          opts[:version] = local_spec.version.to_s
-        end
-
-        plugins = installed_plugins
-        plugins[name] = {
-          "require"     => opts[:require],
-          "gem_version" => opts[:version],
-          "sources"     => opts[:sources],
-        }
-
-        if local_spec.nil?
-          result = nil
-          install_lambda = lambda do
-            Vagrant::Bundler.instance.install(plugins, local).each do |spec|
-              next if spec.name != name
-              next if result && result.version >= spec.version
-              result = spec
-            end
-          end
-
-          if opts[:verbose]
-            Vagrant::Bundler.instance.verbose(&install_lambda)
-          else
-            install_lambda.call
-          end
-        else
-          result = local_spec
-        end
-        # Add the plugin to the state file
-        @user_file.add_plugin(
-          result.name,
-          version: opts[:version],
-          require: opts[:require],
-          sources: opts[:sources],
-          installed_gem_version: result.version.to_s
-        )
-
-        # After install clean plugin gems to remove any cruft. This is useful
-        # for removing outdated dependencies or other versions of an installed
-        # plugin if the plugin is upgraded/downgraded
-        Vagrant::Bundler.instance.clean(installed_plugins)
-        result
-      rescue Gem::GemNotFoundException
-        raise Errors::PluginGemNotFound, name: name
-      rescue Gem::Exception => e
-        raise Errors::BundlerError, message: e.to_s
-      end
-
-      # Uninstalls the plugin with the given name.
-      #
-      # @param [String] name
-      def uninstall_plugin(name)
-        if @system_file
-          if !@user_file.has_plugin?(name) && @system_file.has_plugin?(name)
-            raise Errors::PluginUninstallSystem,
-              name: name
-          end
-        end
-
-        @user_file.remove_plugin(name)
-
-        # Clean the environment, removing any old plugins
-        Vagrant::Bundler.instance.clean(installed_plugins)
-      rescue Gem::Exception => e
-        raise Errors::BundlerError, message: e.to_s
-      end
-
-      # Updates all or a specific set of plugins.
-      def update_plugins(specific)
-        result = Vagrant::Bundler.instance.update(installed_plugins, specific)
-        installed_plugins.each do |name, info|
-          matching_spec = result.detect{|s| s.name == name}
-          info = Hash[
-            info.map do |key, value|
-              [key.to_sym, value]
-            end
-          ]
-          if matching_spec
-            @user_file.add_plugin(name, **info.merge(
-              version: "> 0",
-              installed_gem_version: matching_spec.version.to_s
-            ))
-          end
-        end
-        Vagrant::Bundler.instance.clean(installed_plugins)
-        result
-      rescue Gem::Exception => e
-        raise Errors::BundlerError, message: e.to_s
-      end
-
-      # This returns the list of plugins that should be enabled.
-      #
-      # @return [Hash]
-      def installed_plugins
-        system = {}
-        if @system_file
-          @system_file.installed_plugins.each do |k, v|
-            system[k] = v.merge("system" => true)
-          end
-        end
-        plugin_list = system.merge(@user_file.installed_plugins)
-
-        # Sort plugins by name
-        Hash[
-          plugin_list.map{|plugin_name, plugin_info|
-            [plugin_name, plugin_info]
-          }.sort_by(&:first)
-        ]
-      end
-
-      # This returns the list of plugins that are installed as
-      # Gem::Specifications.
-      #
-      # @return [Array<Gem::Specification>]
-      def installed_specs
-        installed = Set.new(installed_plugins.keys)
-
-        # Go through the plugins installed in this environment and
-        # get the latest version of each.
-        installed_map = {}
-        Gem::Specification.find_all.each do |spec|
-          # Ignore specs that aren't in our installed list
-          next if !installed.include?(spec.name)
-
-          # If we already have a newer version in our list of installed,
-          # then ignore it
-          next if installed_map.key?(spec.name) &&
-            installed_map[spec.name].version >= spec.version
-
-          installed_map[spec.name] = spec
-        end
-
-        installed_map.values
-      end
-    end
-  end
-end

data/vendor/bundle/ruby/2.3.0/bundler/gems/vagrant-5333e60e2d38/lib/vagrant/plugin/v2/command.rb

@@ -1,296 +0,0 @@
-require 'log4r'
-
-require "vagrant/util/safe_puts"
-
-module Vagrant
-  module Plugin
-    module V2
-      # This is the base class for a CLI command.
-      class Command
-        include Util::SafePuts
-
-        # This should return a brief (60 characters or less) synopsis of what
-        # this command does. It will be used in the output of the help.
-        #
-        # @return [String]
-        def self.synopsis
-          ""
-        end
-
-        def initialize(argv, env)
-          @argv = argv
-          @env  = env
-          @logger = Log4r::Logger.new("vagrant::command::#{self.class.to_s.downcase}")
-        end
-
-        # This is what is called on the class to actually execute it. Any
-        # subclasses should implement this method and do any option parsing
-        # and validation here.
-        def execute
-        end
-
-        protected
-
-        # Parses the options given an OptionParser instance.
-        #
-        # This is a convenience method that properly handles duping the
-        # originally argv array so that it is not destroyed.
-        #
-        # This method will also automatically detect "-h" and "--help"
-        # and print help. And if any invalid options are detected, the help
-        # will be printed, as well.
-        #
-        # If this method returns `nil`, then you should assume that help
-        # was printed and parsing failed.
-        def parse_options(opts=nil)
-          # Creating a shallow copy of the arguments so the OptionParser
-          # doesn't destroy the originals.
-          argv = @argv.dup
-
-          # Default opts to a blank optionparser if none is given
-          opts ||= OptionParser.new
-
-          # Add the help option, which must be on every command.
-          opts.on_tail("-h", "--help", "Print this help") do
-            safe_puts(opts.help)
-            return nil
-          end
-
-          opts.parse!(argv)
-          return argv
-        rescue OptionParser::InvalidOption, OptionParser::MissingArgument
-          raise Errors::CLIInvalidOptions, help: opts.help.chomp
-        end
-
-        # Yields a VM for each target VM for the command.
-        #
-        # This is a convenience method for easily implementing methods that
-        # take a target VM (in the case of multi-VM) or every VM if no
-        # specific VM name is specified.
-        #
-        # @param [String] name The name of the VM. Nil if every VM.
-        # @param [Hash] options Additional tweakable settings.
-        # @option options [Symbol] :provider The provider to back the
-        #   machines with. All machines will be backed with this
-        #   provider. If none is given, a sensible default is chosen.
-        # @option options [Boolean] :reverse If true, the resulting order
-        #   of machines is reversed.
-        # @option options [Boolean] :single_target If true, then an
-        #   exception will be raised if more than one target is found.
-        def with_target_vms(names=nil, options=nil)
-          @logger.debug("Getting target VMs for command. Arguments:")
-          @logger.debug(" -- names: #{names.inspect}")
-          @logger.debug(" -- options: #{options.inspect}")
-
-          # Setup the options hash
-          options ||= {}
-
-          # Require that names be an array
-          names ||= []
-          names = [names] if !names.is_a?(Array)
-
-          # Determine if we require a local Vagrant environment. There are
-          # two cases that we require a local environment:
-          #
-          #   * We're asking for ANY/EVERY VM (no names given).
-          #
-          #   * We're asking for specific VMs, at least once of which
-          #     is NOT in the local machine index.
-          #
-          requires_local_env = false
-          requires_local_env = true if names.empty?
-          requires_local_env ||= names.any? { |n|
-            !@env.machine_index.include?(n)
-          }
-          raise Errors::NoEnvironmentError if requires_local_env && !@env.root_path
-
-          # Cache the active machines outside the loop
-          active_machines = @env.active_machines
-
-          # This is a helper that gets a single machine with the proper
-          # provider. The "proper provider" in this case depends on what was
-          # given:
-          #
-          #   * If a provider was explicitly specified, then use that provider.
-          #     But if an active machine exists with a DIFFERENT provider,
-          #     then throw an error (for now), since we don't yet support
-          #     bringing up machines with different providers.
-          #
-          #   * If no provider was specified, then use the active machine's
-          #     provider if it exists, otherwise use the default provider.
-          #
-          get_machine = lambda do |name|
-            # Check for an active machine with the same name
-            provider_to_use = options[:provider]
-            provider_to_use = provider_to_use.to_sym if provider_to_use
-
-            # If we have this machine in our index, load that.
-            entry = @env.machine_index.get(name.to_s)
-            if entry
-              @env.machine_index.release(entry)
-
-              # Create an environment for this location and yield the
-              # machine in that environment. We silence warnings here because
-              # Vagrantfiles often have constants, so people would otherwise
-              # constantly (heh) get "already initialized constant" warnings.
-              begin
-                env = entry.vagrant_env(
-                  @env.home_path, ui_class: @env.ui_class)
-              rescue Vagrant::Errors::EnvironmentNonExistentCWD
-                # This means that this environment working directory
-                # no longer exists, so delete this entry.
-                entry = @env.machine_index.get(name.to_s)
-                @env.machine_index.delete(entry) if entry
-                raise
-              end
-
-              next env.machine(entry.name.to_sym, entry.provider.to_sym)
-            end
-
-            active_machines.each do |active_name, active_provider|
-              if name == active_name
-                # We found an active machine with the same name
-
-                if provider_to_use && provider_to_use != active_provider
-                  # We found an active machine with a provider that doesn't
-                  # match the requested provider. Show an error.
-                  raise Errors::ActiveMachineWithDifferentProvider,
-                    name: active_name.to_s,
-                    active_provider: active_provider.to_s,
-                    requested_provider: provider_to_use.to_s
-                else
-                  # Use this provider and exit out of the loop. One of the
-                  # invariants [for now] is that there shouldn't be machines
-                  # with multiple providers.
-                  @logger.info("Active machine found with name #{active_name}. " +
-                               "Using provider: #{active_provider}")
-                  provider_to_use = active_provider
-                  break
-                end
-              end
-            end
-
-            # Use the default provider if nothing else
-            provider_to_use ||= @env.default_provider(machine: name)
-
-            # Get the right machine with the right provider
-            @env.machine(name, provider_to_use)
-          end
-
-          # First determine the proper array of VMs.
-          machines = []
-          if names.length > 0
-            names.each do |name|
-              if pattern = name[/^\/(.+?)\/$/, 1]
-                @logger.debug("Finding machines that match regex: #{pattern}")
-
-                # This is a regular expression name, so we convert to a regular
-                # expression and allow that sort of matching.
-                regex = Regexp.new(pattern)
-
-                @env.machine_names.each do |machine_name|
-                  if machine_name =~ regex
-                    machines << get_machine.call(machine_name)
-                  end
-                end
-
-                raise Errors::VMNoMatchError if machines.empty?
-              else
-                # String name, just look for a specific VM
-                @logger.debug("Finding machine that match name: #{name}")
-                machines << get_machine.call(name.to_sym)
-                raise Errors::VMNotFoundError, name: name if !machines[0]
-              end
-            end
-          else
-            # No name was given, so we return every VM in the order
-            # configured.
-            @logger.debug("Loading all machines...")
-            machines = @env.machine_names.map do |machine_name|
-              get_machine.call(machine_name)
-            end
-          end
-
-          # Make sure we're only working with one VM if single target
-          if options[:single_target] && machines.length != 1
-            @logger.debug("Using primary machine since single target")
-            primary_name = @env.primary_machine_name
-            raise Errors::MultiVMTargetRequired if !primary_name
-            machines = [get_machine.call(primary_name)]
-          end
-
-          # If we asked for reversed ordering, then reverse it
-          machines.reverse! if options[:reverse]
-
-          # Go through each VM and yield it!
-          color_order = [:default]
-          color_index = 0
-
-          machines.each do |machine|
-            # Set the machine color
-            machine.ui.opts[:color] = color_order[color_index % color_order.length]
-            color_index += 1
-
-            @logger.info("With machine: #{machine.name} (#{machine.provider.inspect})")
-            yield machine
-
-            # Call the state method so that we update our index state. Don't
-            # worry about exceptions here, since we just care about updating
-            # the cache.
-            begin
-              # Called for side effects
-              machine.state
-            rescue Errors::VagrantError
-            end
-          end
-        end
-
-        # This method will split the argv given into three parts: the
-        # flags to this command, the subcommand, and the flags to the
-        # subcommand. For example:
-        #
-        #     -v status -h -v
-        #
-        # The above would yield 3 parts:
-        #
-        #     ["-v"]
-        #     "status"
-        #     ["-h", "-v"]
-        #
-        # These parts are useful because the first is a list of arguments
-        # given to the current command, the second is a subcommand, and the
-        # third are the commands given to the subcommand.
-        #
-        # @return [Array] The three parts.
-        def split_main_and_subcommand(argv)
-          # Initialize return variables
-          main_args   = nil
-          sub_command = nil
-          sub_args    = []
-
-          # We split the arguments into two: One set containing any
-          # flags before a word, and then the rest. The rest are what
-          # get actually sent on to the subcommand.
-          argv.each_index do |i|
-            if !argv[i].start_with?("-")
-              # We found the beginning of the sub command. Split the
-              # args up.
-              main_args   = argv[0, i]
-              sub_command = argv[i]
-              sub_args    = argv[i + 1, argv.length - i + 1]
-
-              # Break so we don't find the next non flag and shift our
-              # main args.
-              break
-            end
-          end
-
-          # Handle the case that argv was empty or didn't contain any subcommand
-          main_args = argv.dup if main_args.nil?
-
-          return [main_args, sub_command, sub_args]
-        end
-      end
-    end
-  end
-end

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

@@ -1,119 +0,0 @@
-require "pathname"
-require "tempfile"
-require "thread"
-
-module Vagrant
-  @@global_lock = Mutex.new
-
-  # This is the default endpoint of the Atlas in
-  # use. API calls will be made to this for various functions
-  # of Vagrant that may require remote access.
-  #
-  # @return [String]
-  DEFAULT_SERVER_URL = "https://atlas.hashicorp.com"
-
-  # Max number of seconds to wait for joining an active thread.
-  #
-  # @return [Integer]
-  # @note This is not the maxium time for a thread to complete.
-  THREAD_MAX_JOIN_TIMEOUT = 60
-
-  # This holds a global lock for the duration of the block. This should
-  # be invoked around anything that is modifying process state (such as
-  # environmental variables).
-  def self.global_lock
-    @@global_lock.synchronize do
-      return yield
-    end
-  end
-
-  # This returns a true/false showing whether we're running from the
-  # environment setup by the Vagrant installers.
-  #
-  # @return [Boolean]
-  def self.in_installer?
-    !!ENV["VAGRANT_INSTALLER_ENV"]
-  end
-
-  # Returns the path to the embedded directory of the Vagrant installer,
-  # if there is one (if we're running in an installer).
-  #
-  # @return [String]
-  def self.installer_embedded_dir
-    return nil if !Vagrant.in_installer?
-    ENV["VAGRANT_INSTALLER_EMBEDDED_DIR"]
-  end
-
-  # Should the plugin system be initialized
-  #
-  # @return [Boolean]
-  def self.plugins_init?
-    !ENV['VAGRANT_DISABLE_PLUGIN_INIT']
-  end
-
-  # This returns whether or not 3rd party plugins should and can be loaded.
-  #
-  # @return [Boolean]
-  def self.plugins_enabled?
-    !ENV["VAGRANT_NO_PLUGINS"]
-  end
-
-  # Whether or not super quiet mode is enabled. This is ill-advised.
-  #
-  # @return [Boolean]
-  def self.very_quiet?
-    !!ENV["VAGRANT_I_KNOW_WHAT_IM_DOING_PLEASE_BE_QUIET"]
-  end
-
-  # The current log level for Vagrant
-  #
-  # @return [String]
-  def self.log_level
-    ENV["VAGRANT_LOG"]
-  end
-
-  # Returns the URL prefix to the server.
-  #
-  # @return [String]
-  def self.server_url(config_server_url=nil)
-    result = ENV["VAGRANT_SERVER_URL"]
-    result = config_server_url if result == "" or result == nil
-    result || DEFAULT_SERVER_URL
-  end
-
-  # The source root is the path to the root directory of the Vagrant source.
-  #
-  # @return [Pathname]
-  def self.source_root
-    @source_root ||= Pathname.new(File.expand_path('../../../', __FILE__))
-  end
-
-  # This returns the path to the ~/.vagrant.d folder where Vagrant's
-  # per-user state is stored.
-  #
-  # @return [Pathname]
-  def self.user_data_path
-    # Use user spcified env var if available
-    path = ENV["VAGRANT_HOME"]
-
-    # On Windows, we default to the USERPROFILE directory if it
-    # is available. This is more compatible with Cygwin and sharing
-    # the home directory across shells.
-    if !path && ENV["USERPROFILE"]
-      path = "#{ENV["USERPROFILE"]}/.vagrant.d"
-    end
-
-    # Fallback to the default
-    path ||= "~/.vagrant.d"
-
-    Pathname.new(path).expand_path
-  end
-
-  # This returns true/false if the running version of Vagrant is
-  # a pre-release version (development)
-  #
-  # @return [Boolean]
-  def self.prerelease?
-    Gem::Version.new(Vagrant::VERSION).prerelease?
-  end
-end

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

@@ -1,47 +0,0 @@
-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 used
-        #
-        # @return [Boolean]
-        def systemd?(comm)
-          comm.test("systemctl | grep '^-\.mount'")
-        end
-
-        # systemd hostname set is via hostnamectl
-        #
-        # @return [Boolean]
-        def hostnamectl?(comm)
-          comm.test("hostnamectl")
-        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

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

@@ -1,39 +0,0 @@
-require "socket"
-require "timeout"
-
-module Vagrant
-  module Util
-    # Contains the method {#is_port_open?} to check if a port is open
-    # (listening) or closed (not in use). This method isn't completely
-    # fool-proof, but it works enough of the time to be useful.
-    module IsPortOpen
-      # Checks if a port is open (listening) on a given host and port.
-      #
-      # @param [String] host Hostname or IP address.
-      # @param [Integer] port Port to check.
-      # @return [Boolean] `true` if the port is open (listening), `false`
-      #   otherwise.
-      def is_port_open?(host, port)
-        # We wrap this in a timeout because once in awhile the TCPSocket
-        # _will_ hang, but this signals that the port is closed.
-        Timeout.timeout(1) do
-          # Attempt to make a connection
-          s = TCPSocket.new(host, port)
-
-          # A connection was made! Properly clean up the socket, not caring
-          # at all if any exception is raised, because we already know the
-          # result.
-          s.close rescue nil
-
-          # The port is open if we reached this point, since we were able
-          # to connect.
-          return true
-        end
-      rescue Timeout::Error, Errno::ECONNREFUSED, Errno::EHOSTUNREACH, \
-             Errno::ENETUNREACH, Errno::EACCES, Errno::ENOTCONN
-        # Any of the above exceptions signal that the port is closed.
-        return false
-      end
-    end
-  end
-end