vagrant 1.5.0 → 2.4.4

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

@@ -0,0 +1,367 @@
+# Copyright (c) HashiCorp, Inc.
+# SPDX-License-Identifier: BUSL-1.1
+
+require 'fileutils'
+require 'log4r'
+require 'shellwords'
+
+require Vagrant.source_root.join("plugins/provisioners/shell/provisioner")
+require "vagrant/util/subprocess"
+require "vagrant/util/platform"
+require "vagrant/util/powershell"
+
+module Vagrant
+  module Plugin
+    module V2
+      class Trigger
+        # @return [Kernel_V2::Config::Trigger]
+        attr_reader :config
+
+        # This class is responsible for setting up basic triggers that were
+        # defined inside a Vagrantfile.
+        #
+        # @param [Vagrant::Environment] env Vagrant environment
+        # @param [Kernel_V2::TriggerConfig] config Trigger configuration
+        # @param [Vagrant::Machine] machine Active Machine
+        # @param [Vagrant::UI] ui Class for printing messages to user
+        def initialize(env, config, machine, ui)
+          @env        = env
+          @config     = config
+          @machine    = machine
+          @ui         = ui
+
+          @logger = Log4r::Logger.new("vagrant::trigger::#{self.class.to_s.downcase}")
+        end
+
+        # Fires all triggers, if any are defined for the named type and guest. Returns early
+        # and logs a warning if the community plugin `vagrant-triggers` is installed
+        #
+        # @param [Symbol] name Name of `type` thing to fire trigger on
+        # @param [Symbol] stage :before or :after
+        # @param [String] guest The guest that invoked firing the triggers
+        # @param [Symbol] type Type of trigger to fire (:action, :hook, :command)
+        def fire(name, stage, guest, type, all: false)
+          if community_plugin_detected?
+            @logger.warn("Community plugin `vagrant-triggers detected, so core triggers will not fire")
+            return
+          end
+
+          return @logger.warn("Name given is nil, no triggers will fire") if !name
+          return @logger.warn("Name given cannot be symbolized, no triggers will fire") if
+            !name.respond_to?(:to_sym)
+
+          name = name.to_sym
+
+          # get all triggers matching action
+          triggers = find(name, stage, guest, type, all: all)
+
+          if !triggers.empty?
+            @logger.info("Firing trigger for #{type} #{name} on guest #{guest}")
+            @ui.info(I18n.t("vagrant.trigger.start", type: type, stage: stage, name: name))
+            execute(triggers)
+          end
+        end
+
+        # Find all triggers defined for the named type and guest.
+        #
+        # @param [Symbol] name Name of `type` thing to fire trigger on
+        # @param [Symbol] stage :before or :after
+        # @param [String] guest The guest that invoked firing the triggers
+        # @param [Symbol] type Type of trigger to fire
+        # @return [Array]
+        def find(name, stage, guest, type, all: false)
+          triggers = nil
+          name = nameify(name)
+
+          if stage == :before
+            triggers = config.before_triggers.select do |t|
+              (all && t.command.respond_to?(:to_sym) && t.command.to_sym == :all && !t.ignore.include?(name.to_sym)) ||
+                (type == :hook && matched_hook?(t.command, name)) ||
+                nameify(t.command) == name
+            end
+          elsif stage == :after
+            triggers = config.after_triggers.select do |t|
+              (all && t.command.respond_to?(:to_sym) && t.command.to_sym == :all && !t.ignore.include?(name.to_sym)) ||
+                (type == :hook && matched_hook?(t.command, name)) ||
+                nameify(t.command) == name
+            end
+          else
+            raise Errors::TriggersNoStageGiven,
+              name: name,
+              stage: stage,
+              type: type,
+              guest_name: guest
+          end
+
+          filter_triggers(triggers, guest, type)
+        end
+
+        protected
+
+        # Convert object into name
+        #
+        # @param [Object, Class] object Object to name
+        # @return [String]
+        def nameify(object)
+          if object.is_a?(Class)
+            object.name.to_s
+          else
+            object.to_s
+          end
+        end
+
+        #-------------------------------------------------------------------
+        # Internal methods, don't call these.
+        #-------------------------------------------------------------------
+
+        # Generate all valid lookup keys for given action key
+        #
+        # @param [Class, String] key Base key for generation
+        # @return [Array<String>] all valid keys
+        def matched_hook?(key, subject)
+          subject = nameify(subject)
+          Vagrant.plugin("2").manager.generate_hook_keys(key).any? do |k|
+            k == subject
+          end
+        end
+
+        # Looks up if the community plugin `vagrant-triggers` is installed
+        # and also caches the result
+        #
+        # @return [Boolean]
+        def community_plugin_detected?
+          if !defined?(@_triggers_enabled)
+            plugins = Vagrant::Plugin::Manager.instance.installed_plugins
+            @_triggers_enabled = plugins.keys.include?("vagrant-triggers")
+          end
+          @_triggers_enabled
+        end
+
+        # Filters triggers to be fired based on configured restraints
+        #
+        # @param [Array] triggers An array of triggers to be filtered
+        # @param [String] guest_name The name of the current guest
+        # @param [Symbol] type The type of trigger (:command or :type)
+        # @return [Array] The filtered array of triggers
+        def filter_triggers(triggers, guest_name, type)
+          # look for only_on trigger constraint and if it doesn't match guest
+          # name, throw it away also be sure to preserve order
+          filter = triggers.dup
+
+          filter.each do |trigger|
+            index = nil
+            match = false
+            if trigger.only_on
+              trigger.only_on.each do |o|
+                if o.match(guest_name.to_s)
+                  # trigger matches on current guest, so we're fine to use it
+                  match = true
+                  break
+                end
+              end
+              # no matches found, so don't use trigger for guest
+              index = triggers.index(trigger) unless match == true
+            end
+
+            if trigger.type != type
+              index = triggers.index(trigger)
+            end
+
+            if index
+              @logger.debug("Trigger #{trigger.id} will be ignored for #{guest_name}")
+              triggers.delete_at(index)
+            end
+          end
+
+          return triggers
+        end
+
+        # Execute all triggers in the given array
+        #
+        # @param [Array] triggers An array of triggers to be fired
+        def execute(triggers)
+          # ensure on_error is respected by exiting or continuing
+          triggers.each do |trigger|
+            @logger.debug("Running trigger #{trigger.id}...")
+
+            if trigger.name
+              @ui.info(I18n.t("vagrant.trigger.fire_with_name",
+                                      name: trigger.name))
+            else
+              @ui.info(I18n.t("vagrant.trigger.fire"))
+            end
+
+            if trigger.info
+              info(trigger.info)
+            end
+
+            if trigger.warn
+              warn(trigger.warn)
+            end
+
+            if trigger.abort
+              trigger_abort(trigger.abort)
+            end
+
+            if trigger.run
+              run(trigger.run, trigger.on_error, trigger.exit_codes)
+            end
+
+            if trigger.run_remote
+              run_remote(trigger.run_remote, trigger.on_error, trigger.exit_codes)
+            end
+
+            if trigger.ruby_block
+              execute_ruby(trigger.ruby_block)
+            end
+          end
+        end
+
+        # Prints the given message at info level for a trigger
+        #
+        # @param [String] message The string to be printed
+        def info(message)
+          @ui.info(message)
+        end
+
+        # Prints the given message at warn level for a trigger
+        #
+        # @param [String] message The string to be printed
+        def warn(message)
+          @ui.warn(message)
+        end
+
+        # Runs a script on a guest
+        #
+        # @param [Provisioners::Shell::Config] config A Shell provisioner config
+        def run(config, on_error, exit_codes)
+          if config.inline
+            if Vagrant::Util::Platform.windows?
+              cmd = config.inline
+            else
+              cmd = Shellwords.split(config.inline)
+            end
+
+            @ui.detail(I18n.t("vagrant.trigger.run.inline", command: config.inline))
+          else
+            cmd = File.expand_path(config.path, @env.root_path).shellescape
+            args = Array(config.args)
+            cmd << " #{args.join(' ')}" if !args.empty?
+            cmd = Shellwords.split(cmd)
+
+            @ui.detail(I18n.t("vagrant.trigger.run.script", path: config.path))
+          end
+
+          # Pick an execution method to run the script or inline string with
+          # Default to Subprocess::Execute
+          exec_method = Vagrant::Util::Subprocess.method(:execute)
+
+          if Vagrant::Util::Platform.windows?
+            if config.inline
+              exec_method = Vagrant::Util::PowerShell.method(:execute_inline)
+            else
+              exec_method = Vagrant::Util::PowerShell.method(:execute)
+            end
+          end
+
+          begin
+            result = exec_method.call(*cmd, :notify => [:stdout, :stderr]) do |type,data|
+              options = {}
+              case type
+              when :stdout
+                options[:color] = :green if !config.keep_color
+              when :stderr
+                options[:color] = :red if !config.keep_color
+              end
+
+              @ui.detail(data, **options)
+            end
+            if !exit_codes.include?(result.exit_code)
+              raise Errors::TriggersBadExitCodes,
+                code: result.exit_code
+            end
+          rescue => e
+            @ui.error(I18n.t("vagrant.errors.triggers_run_fail"))
+            @ui.error(e.message)
+
+            if on_error == :halt
+              @logger.debug("Trigger run encountered an error. Halting on error...")
+              raise e
+            else
+              @logger.debug("Trigger run encountered an error. Continuing on anyway...")
+              @ui.warn(I18n.t("vagrant.trigger.on_error_continue"))
+            end
+          end
+        end
+
+        # Runs a script on the guest
+        #
+        # @param [ShellProvisioner/Config] config A Shell provisioner config
+        def run_remote(config, on_error, exit_codes)
+          if !@machine
+            # machine doesn't even exist.
+            if on_error == :halt
+              raise Errors::TriggersGuestNotExist
+            else
+              @ui.warn(I18n.t("vagrant.errors.triggers_guest_not_exist"))
+              @ui.warn(I18n.t("vagrant.trigger.on_error_continue"))
+              return
+            end
+          elsif @machine.state.id != :running
+            if on_error == :halt
+              raise Errors::TriggersGuestNotRunning,
+                machine_name: @machine.name,
+                state: @machine.state.id
+            else
+              @machine.ui.error(I18n.t("vagrant.errors.triggers_guest_not_running",
+                                        machine_name: @machine.name,
+                                        state: @machine.state.id))
+              @machine.ui.warn(I18n.t("vagrant.trigger.on_error_continue"))
+              return
+            end
+          end
+
+          prov = VagrantPlugins::Shell::Provisioner.new(@machine, config)
+
+          begin
+            prov.provision
+          rescue => e
+            @machine.ui.error(I18n.t("vagrant.errors.triggers_run_fail"))
+
+            if on_error == :halt
+              @logger.debug("Trigger run encountered an error. Halting on error...")
+              raise e
+            else
+              @logger.debug("Trigger run encountered an error. Continuing on anyway...")
+              @machine.ui.error(e.message)
+            end
+          end
+        end
+
+        # Exits Vagrant immediately
+        #
+        # @param [Integer] code Code to exit Vagrant on
+        def trigger_abort(exit_code)
+          if Thread.current[:batch_parallel_action]
+            @ui.warn(I18n.t("vagrant.trigger.abort_threaded"))
+            @logger.debug("Trigger abort within parallel batch action. " \
+              "Setting exit code and terminating.")
+            Thread.current[:exit_code] = exit_code
+            Thread.current.terminate
+          else
+            @ui.warn(I18n.t("vagrant.trigger.abort"))
+            @logger.debug("Trigger abort within non-parallel action, exiting directly")
+            Process.exit!(exit_code)
+          end
+        end
+
+        # Calls the given ruby block for execution
+        #
+        # @param [Proc] ruby_block
+        def execute_ruby(ruby_block)
+          ruby_block.call(@env, @machine)
+        end
+      end
+    end
+  end
+end

data/lib/vagrant/plugin/v2.rb

@@ -0,0 +1,33 @@
+# Copyright (c) HashiCorp, Inc.
+# SPDX-License-Identifier: BUSL-1.1
+
+require "log4r"
+
+# We don't autoload components because if we're loading anything in the
+# V2 namespace anyways, then we're going to need the Components class.
+require "vagrant/plugin/v2/components"
+require "vagrant/plugin/v2/errors"
+
+module Vagrant
+  module Plugin
+    module V2
+      autoload :Command, "vagrant/plugin/v2/command"
+      autoload :Communicator, "vagrant/plugin/v2/communicator"
+      autoload :Components, "vagrant/plugin/v2/components"
+      autoload :Config, "vagrant/plugin/v2/config"
+      autoload :Guest,  "vagrant/plugin/v2/guest"
+      autoload :Host,   "vagrant/plugin/v2/host"
+      autoload :Manager, "vagrant/plugin/v2/manager"
+      autoload :Plugin, "vagrant/plugin/v2/plugin"
+      autoload :Provider, "vagrant/plugin/v2/provider"
+      autoload :Push, "vagrant/plugin/v2/push"
+      autoload :Provisioner, "vagrant/plugin/v2/provisioner"
+      autoload :SyncedFolder, "vagrant/plugin/v2/synced_folder"
+      autoload :Trigger, "vagrant/plugin/v2/trigger"
+
+      # Errors
+      autoload :Error, "vagrant/plugin/v2/error"
+      autoload :InvalidCommandName, "vagrant/plugin/v2/error"
+    end
+  end
+end

data/lib/vagrant/plugin.rb

@@ -0,0 +1,11 @@
+# Copyright (c) HashiCorp, Inc.
+# SPDX-License-Identifier: BUSL-1.1
+
+module Vagrant
+  module Plugin
+    autoload :V1,        "vagrant/plugin/v1"
+    autoload :V2,        "vagrant/plugin/v2"
+    autoload :Manager,   "vagrant/plugin/manager"
+    autoload :StateFile, "vagrant/plugin/state_file"
+  end
+end

data/lib/vagrant/registry.rb

@@ -0,0 +1,113 @@
+# Copyright (c) HashiCorp, Inc.
+# SPDX-License-Identifier: BUSL-1.1
+
+module Vagrant
+  # Register components in a single location that can be queried.
+  #
+  # This allows certain components (such as guest systems, configuration
+  # pieces, etc.) to be registered and queried, lazily.
+  class Registry
+    def initialize
+      @items = {}
+      @results_cache = {}
+    end
+
+    # Register a key with a lazy-loaded value.
+    #
+    # If a key with the given name already exists, it is overwritten.
+    def register(key, &block)
+      raise ArgumentError, "block required" if !block_given?
+      @items[key] = block
+    end
+
+    # Get a value by the given key.
+    #
+    # This will evaluate the block given to `register` and return the
+    # resulting value.
+    def get(key)
+      return nil if !@items.key?(key)
+      return @results_cache[key] if @results_cache.key?(key)
+      @results_cache[key] = @items[key].call
+    end
+    alias :[] :get
+
+    # Checks if the given key is registered with the registry.
+    #
+    # @return [Boolean]
+    def key?(key)
+      @items.key?(key)
+    end
+    alias_method :has_key?, :key?
+
+    # Returns an array populated with the keys of this object.
+    #
+    # @return [Array]
+    def keys
+      @items.keys
+    end
+
+    # Iterate over the keyspace.
+    def each(&block)
+      @items.each do |key, _|
+        yield key, get(key)
+      end
+    end
+
+    # Iterate over the keyspace and return result
+    #
+    # @return [Array]
+    def map(&block)
+      @items.map do |key, _|
+        yield key, get(key)
+      end
+    end
+
+    # Return the number of elements in this registry.
+    #
+    # @return [Integer]
+    def length
+      @items.keys.length
+    end
+    alias_method :size, :length
+
+    # Checks if this registry has any items.
+    #
+    # @return [Boolean]
+    def empty?
+      @items.keys.empty?
+    end
+
+    # Merge one registry with another and return a completely new
+    # registry. Note that the result cache is completely busted, so
+    # any gets on the new registry will result in a cache miss.
+    def merge(other)
+      self.class.new.tap do |result|
+        result.merge!(self)
+        result.merge!(other)
+      end
+    end
+
+    # Like #{merge} but merges into self.
+    def merge!(other)
+      @items.merge!(other.__internal_state[:items])
+      self
+    end
+
+    # Converts this registry to a hash
+    def to_hash
+      result = {}
+      self.each do |key, value|
+        result[key] = value
+      end
+
+      result
+    end
+
+    def __internal_state
+      {
+        items: @items,
+        results_cache: @results_cache
+      }
+    end
+  end
+end