vagrant 1.5.0 → 2.4.4

data/lib/vagrant/action/builtin/is_env_set.rb

@@ -0,0 +1,25 @@
+# Copyright (c) HashiCorp, Inc.
+# SPDX-License-Identifier: BUSL-1.1
+
+module Vagrant
+  module Action
+    module Builtin
+      # This middleware is meant to be used with Call and can check if
+      # a variable in env is set.
+      class IsEnvSet
+        def initialize(app, env, key, **opts)
+          @app    = app
+          @logger = Log4r::Logger.new("vagrant::action::builtin::is_env_set")
+          @key    = key
+        end
+
+        def call(env)
+          @logger.debug("Checking if env is set: '#{@key}'")
+          env[:result] = !!env[@key]
+          @logger.debug(" - Result: #{env[:result].inspect}")
+          @app.call(env)
+        end
+      end
+    end
+  end
+end

data/lib/vagrant/action/builtin/is_state.rb

@@ -0,0 +1,35 @@
+# Copyright (c) HashiCorp, Inc.
+# SPDX-License-Identifier: BUSL-1.1
+
+module Vagrant
+  module Action
+    module Builtin
+      # This middleware is meant to be used with Call and can check if
+      # a machine is in the given state ID.
+      class IsState
+        # Note: Any of the arguments can be arrays as well.
+        #
+        # @param [Symbol] target_state The target state ID that means that
+        #   the machine was properly shut down.
+        # @param [Symbol] source_state The source state ID that the machine
+        #   must be in to be shut down.
+        def initialize(app, env, check, **opts)
+          @app    = app
+          @logger = Log4r::Logger.new("vagrant::action::builtin::is_state")
+          @check  = check
+          @invert = !!opts[:invert]
+        end
+
+        def call(env)
+          @logger.debug("Checking if machine state is '#{@check}'")
+          state = env[:machine].state.id
+          @logger.debug("-- Machine state: #{state}")
+
+          env[:result] = @check == state
+          env[:result] = !env[:result] if @invert
+          @app.call(env)
+        end
+      end
+    end
+  end
+end

data/lib/vagrant/action/builtin/lock.rb

@@ -0,0 +1,60 @@
+# Copyright (c) HashiCorp, Inc.
+# SPDX-License-Identifier: BUSL-1.1
+
+require "log4r"
+
+module Vagrant
+  module Action
+    module Builtin
+      # This class creates a multi-process lock using `flock`. The lock
+      # is active for the remainder of the middleware stack.
+      class Lock
+        def initialize(app, env, options=nil)
+          @app     = app
+          @logger  = Log4r::Logger.new("vagrant::action::builtin::lock")
+          @options ||= options || {}
+          raise ArgumentError, "Please specify a lock path" if !@options[:path]
+          raise ArgumentError, "Please specify an exception." if !@options[:exception]
+        end
+
+        def call(env)
+          lock_path = @options[:path]
+          lock_path = lock_path.call(env) if lock_path.is_a?(Proc)
+
+          env_key   = "has_lock_#{lock_path}"
+
+          if !env[env_key]
+            # If we already have the key in our environment we assume the
+            # lock is held by our middleware stack already and we allow
+            # nesting.
+            File.open(lock_path, "w+") do |f|
+              # The file locking fails only if it returns "false." If it
+              # succeeds it returns a 0, so we must explicitly check for
+              # the proper error case.
+              @logger.info("Locking: #{lock_path}")
+              if f.flock(File::LOCK_EX | File::LOCK_NB) === false
+                exception = @options[:exception]
+                exception = exception.call(env) if exception.is_a?(Proc)
+                raise exception
+              end
+
+              # Set that we gained the lock and call deeper into the
+              # middleware, but make sure we UNSET the lock when we leave.
+              begin
+                env[env_key] = true
+                @app.call(env)
+              ensure
+                @logger.info("Unlocking: #{lock_path}")
+                env[env_key] = false
+                f.flock(File::LOCK_UN)
+              end
+            end
+          else
+            # Just call up the middleware because we already hold the lock
+            @app.call(env)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/vagrant/action/builtin/message.rb

@@ -0,0 +1,29 @@
+# Copyright (c) HashiCorp, Inc.
+# SPDX-License-Identifier: BUSL-1.1
+
+module Vagrant
+  module Action
+    module Builtin
+      # This middleware simply outputs a message to the UI.
+      class Message
+        def initialize(app, env, message, **opts)
+          @app     = app
+          @message = message
+          @opts    = opts
+        end
+
+        def call(env)
+          if !@opts[:post]
+            env[:ui].output(@message)
+          end
+
+          @app.call(env)
+
+          if @opts[:post]
+            env[:ui].output(@message)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/vagrant/action/builtin/mixin_provisioners.rb

@@ -0,0 +1,159 @@
+# Copyright (c) HashiCorp, Inc.
+# SPDX-License-Identifier: BUSL-1.1
+
+module Vagrant
+  module Action
+    module Builtin
+      module MixinProvisioners
+        # This returns all the instances of the configured provisioners.
+        # This is safe to call multiple times since it will cache the results.
+        #
+        # @return [Array<Provisioner, Hash>]
+        def provisioner_instances(env)
+          return @_provisioner_instances if @_provisioner_instances
+
+          # Make the mapping that'll keep track of provisioner => type
+          @_provisioner_types = {}
+
+          # Get all the configured provisioners
+          @_provisioner_instances = env[:machine].config.vm.provisioners.map do |provisioner|
+            # Instantiate the provisioner
+            klass  = Vagrant.plugin("2").manager.provisioners[provisioner.type]
+
+            # This can happen in the case the configuration isn't validated.
+            next nil if !klass
+
+            result = klass.new(env[:machine], provisioner.config)
+
+            # Store in the type map so that --provision-with works properly
+            @_provisioner_types[result] = provisioner.type
+
+            # Set top level provisioner name to provisioner configs name if top level name not set.
+            # This is mostly for handling the shell provisioner, if a user has set its name like:
+            #
+            #   config.vm.provision "shell", name: "my_provisioner"
+            #
+            # Where `name` is a shell config option, not a top level provisioner class option
+            #
+            # Note: `name` is set to a symbol, since it is converted to one via #Config::VM.provision
+            provisioner_name = provisioner.name
+            if !provisioner_name
+              if provisioner.config.respond_to?(:name) &&
+                  provisioner.config.name
+                provisioner_name = provisioner.config.name.to_sym
+              end
+            else
+              provisioner_name = provisioner_name.to_sym
+            end
+
+            # Build up the options
+            options = {
+              name: provisioner_name,
+              run:  provisioner.run,
+              before:  provisioner.before,
+              after:  provisioner.after,
+              communicator_required: provisioner.communicator_required,
+            }
+
+            # Return the result
+            [result, options]
+          end
+
+          @_provisioner_instances = sort_provisioner_instances(@_provisioner_instances)
+          return @_provisioner_instances.compact
+        end
+
+        private
+
+        # Sorts provisioners based on order specified with before/after options
+        #
+        # @return [Array<Provisioner, Hash>]
+        def sort_provisioner_instances(pvs)
+          final_provs = []
+          root_provs = []
+          # extract root provisioners
+          root_provs = pvs.find_all { |_, o| o[:before].nil? && o[:after].nil? }
+
+          if root_provs.size == pvs.size
+            # no dependencies found
+            return pvs
+          end
+
+          # ensure placeholder variables are Arrays
+          dep_provs = []
+          each_provs = []
+          all_provs = []
+
+          # extract dependency provisioners
+          dep_provs = pvs.find_all { |_, o| o[:before].is_a?(String) || o[:after].is_a?(String) }
+          # extract each provisioners
+          each_provs = pvs.find_all { |_,o| o[:before] == :each || o[:after] == :each }
+          # extract all provisioners
+          all_provs = pvs.find_all { |_,o| o[:before] == :all || o[:after] == :all }
+
+          # insert provisioners in order
+          final_provs = root_provs
+          dep_provs.each do |p,options|
+            idx = 0
+            if options[:before]
+              idx = final_provs.index { |_, o| o[:name].to_s == options[:before] }
+              final_provs.insert(idx, [p, options])
+            elsif options[:after]
+              idx = final_provs.index { |_, o| o[:name].to_s == options[:after] }
+              idx += 1
+              final_provs.insert(idx, [p, options])
+            end
+          end
+
+          # Add :each and :all provisioners in reverse to preserve order in Vagrantfile
+          tmp_final_provs = []
+          final_provs.each_with_index do |(prv,o), i|
+            tmp_before = []
+            tmp_after = []
+
+            each_provs.reverse_each do |p, options|
+              if options[:before]
+                tmp_before << [p,options]
+              elsif options[:after]
+                tmp_after << [p,options]
+              end
+            end
+
+            tmp_final_provs += tmp_before unless tmp_before.empty?
+            tmp_final_provs += [[prv,o]]
+            tmp_final_provs += tmp_after unless tmp_after.empty?
+          end
+          final_provs = tmp_final_provs
+
+          # Add all to final array
+          all_provs.reverse_each do |p,options|
+            if options[:before]
+              final_provs.insert(0, [p,options])
+            elsif options[:after]
+              final_provs.push([p,options])
+            end
+          end
+
+          return final_provs
+        end
+
+        # This will return a mapping of a provisioner instance to its
+        # type.
+        def provisioner_type_map(env)
+          # Call this in order to initial the map if it hasn't been already
+          provisioner_instances(env)
+
+          # Return the type map
+          @_provisioner_types
+        end
+
+        # @private
+        # Reset the cached values for platform. 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
+end

data/lib/vagrant/action/builtin/mixin_synced_folders.rb

@@ -0,0 +1,267 @@
+# Copyright (c) HashiCorp, Inc.
+# SPDX-License-Identifier: BUSL-1.1
+
+require "json"
+require "set"
+require 'vagrant/util/scoped_hash_override'
+
+module Vagrant
+  module Action
+    module Builtin
+      module MixinSyncedFolders
+        include Vagrant::Util::ScopedHashOverride
+
+        # This goes over all the registered synced folder types and returns
+        # the highest priority implementation that is usable for this machine.
+        def default_synced_folder_type(machine, plugins)
+          ordered = []
+
+          # First turn the plugins into an array
+          plugins.each do |key, data|
+            impl     = data[0]
+            priority = data[1]
+
+            ordered << [priority, key, impl]
+          end
+
+          # Order the plugins by priority. Higher is tried before lower.
+          ordered = ordered.sort { |a, b| b[0] <=> a[0] }
+
+          allowed_types = machine.config.vm.allowed_synced_folder_types
+          if allowed_types
+            ordered = allowed_types.map do |type|
+              ordered.find do |_, key, impl|
+                key == type
+              end
+            end.compact
+          end
+
+          # Find the proper implementation
+          ordered.each do |_, key, impl|
+            return key if impl.new.usable?(machine)
+          end
+
+          return nil
+        end
+
+        # This finds the options in the env that are set for a given
+        # synced folder type.
+        def impl_opts(name, env)
+          {}.tap do |result|
+            env.each do |k, v|
+              if k.to_s.start_with?("#{name}_")
+                # While I generally don't like the 'rescue' syntax,
+                # we do this to just fall back to the default value
+                # if it isn't dup-able.
+                k = k.dup rescue k
+                v = v.dup rescue v
+
+                result[k] = v
+              end
+            end
+          end
+        end
+
+        # This returns the available synced folder implementations. This
+        # is a separate method so that it can be easily stubbed by tests.
+        def plugins
+          @plugins ||= Vagrant.plugin("2").manager.synced_folders
+        end
+
+        # This saves the synced folders data to the machine data directory.
+        # They can then be retrieved again with `synced_folders` by passing
+        # the `cached` option to it.
+        #
+        # @param [Machine] machine The machine that the folders belong to
+        # @param [Hash] folders The result from a {#synced_folders} call.
+        def save_synced_folders(machine, folders, opts={})
+          if opts[:merge]
+            existing = cached_synced_folders(machine)
+            if existing
+              if opts[:vagrantfile]
+                # Go through and find any cached that were from the
+                # Vagrantfile itself. We remove those if it was requested.
+                existing.each do |impl, fs|
+                  fs.each do |id, data|
+                    fs.delete(id) if data[:__vagrantfile]
+                  end
+                end
+              end
+
+              folders.each do |impl, fs|
+                existing[impl] ||= {}
+                fs.each do |id, data|
+                  existing[impl][id] = data
+                end
+              end
+
+              folders = existing
+            end
+          end
+
+          # Remove implementation instances
+          folder_data = JSON.dump(folders.to_h)
+
+          machine.data_dir.join("synced_folders").open("w") do |f|
+            f.write(folder_data)
+          end
+        end
+
+        # This returns the set of shared folders that should be done for
+        # this machine. It returns the folders in a hash keyed by the
+        # implementation class for the synced folders.
+        #
+        # @return [Hash<Symbol, Hash<String, Hash>>]
+        def synced_folders(machine, **opts)
+          return cached_synced_folders(machine) if opts[:cached]
+
+          config = opts[:config]
+          root   = false
+          if !config
+            config = machine.config.vm
+            root   = true
+          end
+
+          config_folders = config.synced_folders
+          folders = Vagrant::Plugin::V2::SyncedFolder::Collection.new
+
+          # Determine all the synced folders as well as the implementation
+          # they're going to use.
+          config_folders.each do |id, data|
+            # Ignore disabled synced folders
+            next if data[:disabled]
+
+            impl = ""
+            impl = data[:type].to_sym if data[:type] && !data[:type].empty?
+
+            if impl != ""
+              impl_class = plugins[impl]
+              if !impl_class
+                # This should never happen because configuration validation
+                # should catch this case. But we put this here as an assert
+                raise "Internal error. Report this as a bug. Invalid: #{data[:type]}"
+              end
+
+              if !opts[:disable_usable_check]
+                if !impl_class[0].new.usable?(machine, true)
+                  # Verify that explicitly defined shared folder types are
+                  # actually usable.
+                  raise Errors::SyncedFolderUnusable, type: data[:type].to_s
+                end
+              end
+            end
+
+            # Get the data to store
+            data = data.dup
+            if root
+              # If these are the root synced folders (attached directly)
+              # to the Vagrantfile, then we mark it as such.
+              data[:__vagrantfile] = true
+            end
+
+            # Keep track of this shared folder by the implementation.
+            folders[impl] ||= {}
+            folders[impl][id] = data
+          end
+
+          # If we have folders with the "default" key, then determine the
+          # most appropriate implementation for this.
+          if folders.key?("") && !folders[""].empty?
+            default_impl = default_synced_folder_type(machine, plugins)
+            if !default_impl
+              types = plugins.to_hash.keys.map { |t| t.to_s }.sort.join(", ")
+              raise Errors::NoDefaultSyncedFolderImpl, types: types
+            end
+
+            folders[default_impl] ||= {}
+            folders[default_impl].merge!(folders[""])
+            folders.delete("")
+          end
+
+          # Apply the scoped hash overrides to get the options
+          folders.dup.each do |impl_name, fs|
+            impl = plugins[impl_name].first.new._initialize(machine, impl_name)
+            new_fs = {}
+            fs.each do |id, data|
+              data[:plugin] = impl
+              id         = data[:id] if data[:id]
+              new_fs[id] = scoped_hash_override(data, impl_name)
+            end
+
+            folders[impl_name] = new_fs
+          end
+
+          folders
+        end
+
+        # This finds the difference between two lists of synced folder
+        # definitions.
+        #
+        # This will return a hash with three keys: "added", "removed",
+        # and "modified". These will contain a set of IDs of folders
+        # that were added, removed, or modified, respectively.
+        #
+        # The parameters should be results from the {#synced_folders} call.
+        #
+        # @return [hash]
+        def synced_folders_diff(one, two)
+          existing_ids = {}
+          one.each do |impl, fs|
+            fs.each do |id, data|
+              existing_ids[id] = data
+            end
+          end
+
+          result = Hash.new { |h, k| h[k] = Set.new }
+          two.each do |impl, fs|
+            fs.each do |id, data|
+              existing = existing_ids.delete(id)
+              if !existing
+                result[:added] << id
+                next
+              end
+
+              # Exists, so we have to compare the host and guestpath, which
+              # is most important...
+              if existing[:hostpath] != data[:hostpath] ||
+                existing[:guestpath] != data[:guestpath]
+                result[:modified] << id
+              end
+            end
+          end
+
+          existing_ids.each do |k, _|
+            result[:removed] << k
+          end
+
+          result
+        end
+
+        protected
+
+        def cached_synced_folders(machine)
+          import = JSON.parse(machine.data_dir.join("synced_folders").read)
+          import.each do |type, folders|
+            impl = plugins[type.to_sym].first.new._initialize(machine, type.to_sym)
+            folders.each { |_, v| v[:plugin] = impl }
+          end
+          # Symbolize the keys we want as symbols
+          import.keys.dup.each do |k|
+            import[k].values.each do |item|
+              item.keys.dup.each do |ik|
+                item[ik.to_sym] = item.delete(ik)
+              end
+            end
+            import[k.to_sym] = import.delete(k)
+          end
+          Vagrant::Plugin::V2::SyncedFolder::Collection[import]
+        rescue Errno::ENOENT
+          # If the file doesn't exist, we probably just have a machine created
+          # by a version of Vagrant that didn't cache shared folders. Report no
+          # shared folders to be safe.
+          Vagrant::Plugin::V2::SyncedFolder::Collection.new
+        end
+      end
+    end
+  end
+end

data/lib/vagrant/action/builtin/prepare_clone.rb

@@ -0,0 +1,41 @@
+# Copyright (c) HashiCorp, Inc.
+# SPDX-License-Identifier: BUSL-1.1
+
+require "log4r"
+
+module Vagrant
+  module Action
+    module Builtin
+      class PrepareClone
+        def initialize(app, env)
+          @app = app
+          @logger = Log4r::Logger.new("vagrant::action::vm::prepare_clone")
+        end
+
+        def call(env)
+          # If we aren't cloning, then do nothing
+          if !env[:machine].config.vm.clone
+            return @app.call(env)
+          end
+
+          # We need to get the machine ID from this Vagrant environment
+          clone_env = env[:machine].env.environment(
+            env[:machine].config.vm.clone)
+          raise Errors::CloneNotFound if !clone_env.root_path
+
+          # Get the machine itself
+          clone_machine = clone_env.machine(
+            clone_env.primary_machine_name, env[:machine].provider_name)
+          raise Errors::CloneMachineNotFound if !clone_machine.id
+
+          # Set the ID of the master so we know what to clone from
+          env[:clone_id] = clone_machine.id
+          env[:clone_machine] = clone_machine
+
+          # Continue
+          @app.call(env)
+        end
+      end
+    end
+  end
+end