vagrant-packet 0.1.2 → 0.1.3

data/vendor/bundle/ruby/2.4.0/bundler/gems/vagrant-04f7215b5e3f/lib/vagrant/plugin/v2/command.rb

@@ -1,299 +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)
-          # make sure optparse doesn't use POSIXLY_CORRECT parsing
-          ENV["POSIXLY_CORRECT"] = 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.4.0/bundler/gems/vagrant-04f7215b5e3f/lib/vagrant/plugin/v2/communicator.rb

@@ -1,123 +0,0 @@
-require "timeout"
-
-module Vagrant
-  module Plugin
-    module V2
-      # Base class for a communicator in Vagrant. A communicator is
-      # responsible for communicating with a machine in some way. There
-      # are various stages of Vagrant that require things such as uploading
-      # files to the machine, executing shell commands, etc. Implementors
-      # of this class are expected to provide this functionality in some
-      # way.
-      #
-      # Note that a communicator must provide **all** of the methods
-      # in this base class. There is currently no way for one communicator
-      # to provide say a more efficient way of uploading a file, but not
-      # provide shell execution. This sort of thing will come in a future
-      # version.
-      class Communicator
-        # This returns true/false depending on if the given machine
-        # can be communicated with using this communicator. If this returns
-        # `true`, then this class will be used as the primary communication
-        # method for the machine.
-        #
-        # @return [Boolean]
-        def self.match?(machine)
-          true
-        end
-
-        # Initializes the communicator with the machine that we will be
-        # communicating with. This base method does nothing (it doesn't
-        # even store the machine in an instance variable for you), so you're
-        # expected to override this and do something with the machine if
-        # you care about it.
-        #
-        # @param [Machine] machine The machine this instance is expected to
-        #   communicate with.
-        def initialize(machine)
-        end
-
-        # Checks if the target machine is ready for communication. If this
-        # returns true, then all the other methods for communicating with
-        # the machine are expected to be functional.
-        #
-        # @return [Boolean]
-        def ready?
-          false
-        end
-
-        # wait_for_ready waits until the communicator is ready, blocking
-        # until then. It will wait up to the given duration or raise an
-        # exception if something goes wrong.
-        #
-        # @param [Integer] duration Timeout in seconds.
-        # @return [Boolean] Will return true on successful connection
-        #   or false on timeout.
-        def wait_for_ready(duration)
-          # By default, we implement a naive solution.
-          begin
-            Timeout.timeout(duration) do
-              while true
-                return true if ready?
-                sleep 0.5
-              end
-            end
-          rescue Timeout::Error
-            # We timed out, we failed.
-          end
-
-          return false
-        end
-
-        # Download a file from the remote machine to the local machine.
-        #
-        # @param [String] from Path of the file on the remote machine.
-        # @param [String] to Path of where to save the file locally.
-        def download(from, to)
-        end
-
-        # Upload a file to the remote machine.
-        #
-        # @param [String] from Path of the file locally to upload.
-        # @param [String] to Path of where to save the file on the remote
-        #   machine.
-        def upload(from, to)
-        end
-
-        # Execute a command on the remote machine. The exact semantics
-        # of this method are up to the implementor, but in general the
-        # users of this class will expect this to be a shell.
-        #
-        # This method gives you no way to write data back to the remote
-        # machine, so only execute commands that don't expect input.
-        #
-        # @param [String] command Command to execute.
-        # @yield [type, data] Realtime output of the command being executed.
-        # @yieldparam [String] type Type of the output. This can be
-        #   `:stdout`, `:stderr`, etc. The exact types are up to the
-        #   implementor.
-        # @yieldparam [String] data Data for the given output.
-        # @return [Integer] Exit code of the command.
-        def execute(command, opts=nil)
-        end
-
-        # Executes a command on the remote machine with administrative
-        # privileges. See {#execute} for documentation, as the API is the
-        # same.
-        #
-        # @see #execute
-        def sudo(command, opts=nil)
-        end
-
-        # Executes a command and returns true if the command succeeded,
-        # and false otherwise. By default, this executes as a normal user,
-        # and it is up to the communicator implementation if they expose an
-        # option for running tests as an administrator.
-        #
-        # @see #execute
-        def test(command, opts=nil)
-        end
-      end
-    end
-  end
-end

data/vendor/bundle/ruby/2.4.0/bundler/gems/vagrant-04f7215b5e3f/lib/vagrant/plugin/v2/components.rb

@@ -1,85 +0,0 @@
-module Vagrant
-  module Plugin
-    module V2
-      # This is the container class for the components of a single plugin.
-      # This allows us to separate the plugin class which defines the
-      # components, and the actual container of those components. This
-      # removes a bit of state overhead from the plugin class itself.
-      class Components
-        # This contains all the action hooks.
-        #
-        # @return [Hash<Symbol, Array>]
-        attr_reader :action_hooks
-
-        # This contains all the command plugins by name, and returns
-        # the command class and options. The command class is wrapped
-        # in a Proc so that it can be lazy loaded.
-        #
-        # @return [Registry<Symbol, Array<Proc, Hash>>]
-        attr_reader :commands
-
-        # This contains all the configuration plugins by scope.
-        #
-        # @return [Hash<Symbol, Registry>]
-        attr_reader :configs
-
-        # This contains all the guests and their parents.
-        #
-        # @return [Registry<Symbol, Array<Class, Symbol>>]
-        attr_reader :guests
-
-        # This contains all the registered guest capabilities.
-        #
-        # @return [Hash<Symbol, Registry>]
-        attr_reader :guest_capabilities
-
-        # This contains all the hosts and their parents.
-        #
-        # @return [Registry<Symbol, Array<Class, Symbol>>]
-        attr_reader :hosts
-
-        # This contains all the registered host capabilities.
-        #
-        # @return [Hash<Symbol, Registry>]
-        attr_reader :host_capabilities
-
-        # This contains all the provider plugins by name, and returns
-        # the provider class and options.
-        #
-        # @return [Hash<Symbol, Registry>]
-        attr_reader :providers
-
-        # This contains all the registered provider capabilities.
-        #
-        # @return [Hash<Symbol, Registry>]
-        attr_reader :provider_capabilities
-
-        # This contains all the push implementations by name.
-        #
-        # @return [Registry<Symbol, Array<Class, Hash>>]
-        attr_reader :pushes
-
-        # This contains all the synced folder implementations by name.
-        #
-        # @return [Registry<Symbol, Array<Class, Integer>>]
-        attr_reader :synced_folders
-
-        def initialize
-          # The action hooks hash defaults to []
-          @action_hooks = Hash.new { |h, k| h[k] = [] }
-
-          @commands = Registry.new
-          @configs = Hash.new { |h, k| h[k] = Registry.new }
-          @guests  = Registry.new
-          @guest_capabilities = Hash.new { |h, k| h[k] = Registry.new }
-          @hosts   = Registry.new
-          @host_capabilities = Hash.new { |h, k| h[k] = Registry.new }
-          @providers = Registry.new
-          @provider_capabilities = Hash.new { |h, k| h[k] = Registry.new }
-          @pushes = Registry.new
-          @synced_folders = Registry.new
-        end
-      end
-    end
-  end
-end

data/vendor/bundle/ruby/2.4.0/bundler/gems/vagrant-04f7215b5e3f/lib/vagrant/plugin/v2/config.rb

@@ -1,143 +0,0 @@
-require "set"
-
-module Vagrant
-  module Plugin
-    module V2
-      # This is the base class for a configuration key defined for
-      # V2. Any configuration key plugins for V2 should inherit from this
-      # class.
-      class Config
-        # This constant represents an unset value. This is useful so it is
-        # possible to know the difference between a configuration value that
-        # was never set, and a value that is nil (explicitly). Best practice
-        # is to initialize all variables to this value, then the {#merge}
-        # method below will "just work" in many cases.
-        UNSET_VALUE = Object.new
-
-        # This is called as a last-minute hook that allows the configuration
-        # object to finalize itself before it will be put into use. This is
-        # a useful place to do some defaults in the case the user didn't
-        # configure something or so on.
-        #
-        # An example of where this sort of thing is used or has been used:
-        # the "vm" configuration key uses this to make sure that at least
-        # one sub-VM has been defined: the default VM.
-        #
-        # The configuration object is expected to mutate itself.
-        def finalize!
-          # Default implementation is to do nothing.
-        end
-
-        # Merge another configuration object into this one. This assumes that
-        # the other object is the same class as this one. This should not
-        # mutate this object, but instead should return a new, merged object.
-        #
-        # The default implementation will simply iterate over the instance
-        # variables and merge them together, with this object overriding
-        # any conflicting instance variables of the older object. Instance
-        # variables starting with "__" (double underscores) will be ignored.
-        # This lets you set some sort of instance-specific state on your
-        # configuration keys without them being merged together later.
-        #
-        # @param [Object] other The other configuration object to merge from,
-        #   this must be the same type of object as this one.
-        # @return [Object] The merged object.
-        def merge(other)
-          result = self.class.new
-
-          # Set all of our instance variables on the new class
-          [self, other].each do |obj|
-            obj.instance_variables.each do |key|
-              # Ignore keys that start with a double underscore. This allows
-              # configuration classes to still hold around internal state
-              # that isn't propagated.
-              if !key.to_s.start_with?("@__")
-                # Don't set the value if it is the unset value, either.
-                value = obj.instance_variable_get(key)
-                result.instance_variable_set(key, value) if value != UNSET_VALUE
-              end
-            end
-          end
-
-          # Persist through the set of invalid methods
-          this_invalid  = @__invalid_methods || Set.new
-          other_invalid = other.instance_variable_get(:"@__invalid_methods") || Set.new
-          result.instance_variable_set(:"@__invalid_methods", this_invalid + other_invalid)
-
-          result
-        end
-
-        # Capture all bad configuration calls and save them for an error
-        # message later during validation.
-        def method_missing(name, *args, &block)
-          return super if @__finalized
-
-          name = name.to_s
-          name = name[0...-1] if name.end_with?("=")
-
-          @__invalid_methods ||= Set.new
-          @__invalid_methods.add(name)
-
-          # Return the dummy object so that anything else works
-          ::Vagrant::Config::V2::DummyConfig.new
-        end
-
-        # Allows setting options from a hash. By default this simply calls
-        # the `#{key}=` method on the config class with the value, which is
-        # the expected behavior most of the time.
-        #
-        # This is expected to mutate itself.
-        #
-        # @param [Hash] options A hash of options to set on this configuration
-        #   key.
-        def set_options(options)
-          options.each do |key, value|
-            send("#{key}=", value)
-          end
-        end
-
-        # Converts this configuration object to JSON.
-        def to_json(*a)
-          instance_variables_hash.to_json(*a)
-        end
-
-        # A default to_s implementation.
-        def to_s
-          self.class.to_s
-        end
-
-        # Returns the instance variables as a hash of key-value pairs.
-        def instance_variables_hash
-          instance_variables.inject({}) do |acc, iv|
-            acc[iv.to_s[1..-1]] = instance_variable_get(iv)
-            acc
-          end
-        end
-
-        # Called after the configuration is finalized and loaded to validate
-        # this object.
-        #
-        # @param [Machine] machine Access to the machine that is being
-        #   validated.
-        # @return [Hash]
-        def validate(machine)
-          return { self.to_s => _detected_errors }
-        end
-
-        # This returns any automatically detected errors.
-        #
-        # @return [Array<String>]
-        def _detected_errors
-          return [] if !@__invalid_methods || @__invalid_methods.empty?
-          return [I18n.t("vagrant.config.common.bad_field",
-                         fields: @__invalid_methods.to_a.sort.join(", "))]
-        end
-
-        # An internal finalize call that no subclass should override.
-        def _finalize!
-          @__finalized = true
-        end
-      end
-    end
-  end
-end

data/vendor/bundle/ruby/2.4.0/bundler/gems/vagrant-04f7215b5e3f/lib/vagrant/plugin/v2/errors.rb

@@ -1,15 +0,0 @@
-# This file contains all the errors that the V2 plugin interface
-# may throw.
-
-module Vagrant
-  module Plugin
-    module V2
-      # Exceptions that can be thrown within the plugin interface all
-      # inherit from this parent exception.
-      class Error < StandardError; end
-
-      # This is thrown when a command name given is invalid.
-      class InvalidCommandName < Error; end
-    end
-  end
-end

data/vendor/bundle/ruby/2.4.0/bundler/gems/vagrant-04f7215b5e3f/lib/vagrant/plugin/v2/guest.rb

@@ -1,23 +0,0 @@
-module Vagrant
-  module Plugin
-    module V2
-      # A base class for a guest OS. A guest OS is responsible for detecting
-      # that the guest operating system running within the machine. The guest
-      # can then be extended with various "guest capabilities" which are their
-      # own form of plugin.
-      #
-      # The guest class itself is only responsible for detecting itself,
-      # and may provide helpers for the capabilities.
-      class Guest
-        # This method is called when the machine is booted and has communication
-        # capabilities in order to detect whether this guest operating system
-        # is running within the machine.
-        #
-        # @return [Boolean]
-        def detect?(machine)
-          false
-        end
-      end
-    end
-  end
-end