vagrant 1.5.0 → 2.4.4

data/lib/vagrant/plugin/v2/command.rb

@@ -0,0 +1,309 @@
+# Copyright (c) HashiCorp, Inc.
+# SPDX-License-Identifier: BUSL-1.1
+
+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 ||= Vagrant::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, OptionParser::AmbiguousOption
+          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
+
+          @logger.info("getting active machines")
+          # 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
+
+          @logger.debug("have machine list to process")
+
+          # 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|
+            if (machine.state && machine.state.id != :not_created &&
+                !machine.index_uuid.nil? && !@env.machine_index.include?(machine.index_uuid))
+              machine.recover_machine(machine.state.id)
+            end
+
+            # 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/lib/vagrant/plugin/v2/communicator.rb

@@ -0,0 +1,133 @@
+# Copyright (c) HashiCorp, Inc.
+# SPDX-License-Identifier: BUSL-1.1
+
+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
+
+        # Reset the communicator. For communicators which establish
+        # a persistent connection to the remote machine, this connection
+        # should be terminated and re-established. The communicator
+        # instance should be in a "fresh" state after calling this method.
+        def reset!
+        end
+      end
+    end
+  end
+end

data/lib/vagrant/plugin/v2/components.rb

@@ -0,0 +1,94 @@
+# Copyright (c) HashiCorp, Inc.
+# SPDX-License-Identifier: BUSL-1.1
+
+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
+
+        # This contains all the registered synced folder capabilities.
+        #
+        # @return [Hash<Symbol, Registry>]
+        attr_reader :synced_folder_capabilities
+
+        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
+          @synced_folder_capabilities = Hash.new { |h, k| h[k] = Registry.new }
+        end
+      end
+    end
+  end
+end