vagrant 1.5.0 → 2.4.4

data/lib/vagrant/action/general/package.rb

@@ -0,0 +1,248 @@
+# Copyright (c) HashiCorp, Inc.
+# SPDX-License-Identifier: BUSL-1.1
+
+require 'fileutils'
+require "pathname"
+require 'vagrant/util/safe_chdir'
+require 'vagrant/util/subprocess'
+require 'vagrant/util/presence'
+
+module Vagrant
+  module Action
+    module General
+      # A general packaging (tar) middleware. Given the following options,
+      # it will do the right thing:
+      #
+      #   * package.output - The filename of the outputted package.
+      #   * package.include - An array of files to include in the package.
+      #   * package.info - Path of desired info.json file to include
+      #   * package.directory - The directory which contains the contents to
+      #       compress into the package.
+      #
+      # This middleware always produces the final file in the current working
+      # directory (FileUtils.pwd)
+      class Package
+        include Util
+
+        # Perform sanity validations that the provided output filepath is sane.
+        # In particular, this function validates:
+        #
+        #   - The output path is a regular file (not a directory or symlink)
+        #   - No file currently exists at the given path
+        #   - A directory of package files was actually provided (internal)
+        #
+        # @param [String] output path to the output file
+        # @param [String] directory path to a directory containing the files
+        def self.validate!(output, directory)
+          filename = File.basename(output.to_s)
+          output   = fullpath(output)
+
+          if File.directory?(output)
+            raise Vagrant::Errors::PackageOutputDirectory
+          end
+
+          if File.exist?(output)
+            raise Vagrant::Errors::PackageOutputExists, filename: filename
+          end
+
+          if !Vagrant::Util::Presence.present?(directory) || !File.directory?(directory)
+            raise Vagrant::Errors::PackageRequiresDirectory
+          end
+        end
+
+        # Calculate the full path of the given path, relative to the current
+        # working directory (where the command was run).
+        #
+        # @param [String] output the relative path
+        def self.fullpath(output)
+          File.expand_path(output, Dir.pwd)
+        end
+
+        # The path to the final output file.
+        # @return [String]
+        attr_reader :fullpath
+
+        def initialize(app, env)
+          @app = app
+
+          env["package.files"]  ||= {}
+          env["package.info"]   ||= ""
+          env["package.output"] ||= "package.box"
+
+          @fullpath = self.class.fullpath(env["package.output"])
+        end
+
+        def call(env)
+          @env = env
+
+          self.class.validate!(env["package.output"], env["package.directory"])
+
+          package_with_folder_path if env["package.output"].include?(File::SEPARATOR)
+
+          raise Errors::PackageOutputDirectory if File.directory?(fullpath)
+
+          raise Errors::PackageInvalidInfo if invalid_info?
+
+          @app.call(env)
+
+          @env[:ui].info I18n.t("vagrant.actions.general.package.compressing", fullpath: fullpath)
+
+          copy_include_files
+          copy_info
+          setup_private_key
+          write_metadata_json
+          compress
+        end
+
+        def package_with_folder_path
+          folder_path = File.expand_path("..", @fullpath)
+          create_box_folder(folder_path) unless File.directory?(folder_path)
+        end
+
+        def create_box_folder(folder_path)
+          @env[:ui].info(I18n.t("vagrant.actions.general.package.box_folder", folder_path: folder_path))
+          FileUtils.mkdir_p(folder_path)
+        end
+
+        def recover(env)
+          @env = env
+
+          # There are certain exceptions that we don't delete the file for.
+          ignore_exc = [Errors::PackageOutputDirectory, Errors::PackageOutputExists]
+          ignore_exc.each do |exc|
+            return if env["vagrant.error"].is_a?(exc)
+          end
+
+          # Cleanup any packaged files if the packaging failed at some point.
+          File.delete(fullpath) if File.exist?(fullpath)
+        end
+
+        # This method copies the include files (passed in via command line)
+        # to the temporary directory so they are included in a sub-folder within
+        # the actual box
+        def copy_include_files
+          include_directory = Pathname.new(@env["package.directory"]).join("include")
+
+          @env["package.files"].each do |from, dest|
+            # We place the file in the include directory
+            to = include_directory.join(dest)
+
+            @env[:ui].info I18n.t("vagrant.actions.general.package.packaging", file: from)
+            FileUtils.mkdir_p(to.parent)
+
+            # Copy directory contents recursively.
+            if File.directory?(from)
+              FileUtils.cp_r(Dir.glob(from), to.parent, preserve: true)
+            else
+              FileUtils.cp(from, to, preserve: true)
+            end
+          end
+        rescue Errno::EEXIST => e
+          raise if !e.to_s.include?("symlink")
+
+          # The directory contains symlinks. Show a nicer error.
+          raise Errors::PackageIncludeSymlink
+        end
+
+        # This method copies the specified info.json file to the temporary directory
+        # so that it is accessible via the 'box list -i' command
+        def copy_info
+          info_path = Pathname.new(@env["package.info"])
+
+          if info_path.file?
+            FileUtils.cp(info_path, @env["package.directory"], preserve: true)
+          end
+        end
+
+        # Compress the exported file into a package
+        def compress
+          # Get the output path. We have to do this up here so that the
+          # pwd returns the proper thing.
+          output_path = fullpath.to_s
+
+          # Switch into that directory and package everything up
+          Util::SafeChdir.safe_chdir(@env["package.directory"]) do
+            # Find all the files in our current directory and tar it up!
+            files = Dir.glob(File.join(".", "*"))
+
+            # Package!
+            Util::Subprocess.execute("bsdtar", "-czf", output_path, *files)
+          end
+        end
+
+        # Write the metadata file into the box so that the provider
+        # can be automatically detected when adding the box
+        def write_metadata_json
+          meta_path = File.join(@env["package.directory"], "metadata.json")
+          return if File.exist?(meta_path)
+
+          if @env[:machine] && @env[:machine].provider_name
+            provider_name = @env[:machine].provider_name
+          elsif @env[:env] && @env[:env].default_provider
+            provider_name = @env[:env].default_provider
+          else
+            return
+          end
+          File.write(meta_path, {provider: provider_name}.to_json)
+        end
+
+        # This will copy the generated private key into the box and use
+        # it for SSH by default. We have to do this because we now generate
+        # random keypairs on boot, so packaged boxes would stop working
+        # without this.
+        def setup_private_key
+          # If we don't have machine, we do nothing (weird)
+          return if !@env[:machine]
+
+          # If we don't have a data dir, we also do nothing (base package)
+          return if !@env[:machine].data_dir
+
+          # If we don't have a generated private key, we do nothing
+          path = @env[:machine].data_dir.join("private_key")
+          if !path.file?
+            # If we have a private key that was copied into this box,
+            # then we copy that. This is a bit of a heuristic and can be a
+            # security risk if the key is named the correct thing, but
+            # we'll take that risk for dev environments.
+            (@env[:machine].config.ssh.private_key_path || []).each do |p|
+              # If we have the correctly named key, copy it
+              if File.basename(p) == "vagrant_private_key"
+                path = Pathname.new(p)
+                break
+              end
+            end
+          end
+
+          # If we still have no matching key, do nothing
+          return if !path.file?
+
+          # Copy it into our box directory
+          dir = Pathname.new(@env["package.directory"])
+          new_path = dir.join("vagrant_private_key")
+          FileUtils.cp(path, new_path)
+
+          # Append it to the Vagrantfile (or create a Vagrantfile)
+          vf_path = dir.join("Vagrantfile")
+          mode = "w+"
+          mode = "a" if vf_path.file?
+          vf_path.open(mode) do |f|
+            f.binmode
+            f.puts
+            f.puts %Q[Vagrant.configure("2") do |config|]
+            f.puts %Q[  config.ssh.private_key_path = File.expand_path("../vagrant_private_key", __FILE__)]
+            f.puts %Q[end]
+          end
+        end
+
+        # Check to see if package.info is a valid file and titled info.json
+        def invalid_info?
+          if @env["package.info"] != ""
+            info_path = Pathname.new(@env["package.info"])
+
+            return !info_path.file? || File.basename(info_path) != "info.json"
+          end
+        end
+      end
+    end
+  end
+end

data/lib/vagrant/action/general/package_setup_files.rb

@@ -0,0 +1,54 @@
+# Copyright (c) HashiCorp, Inc.
+# SPDX-License-Identifier: BUSL-1.1
+
+module Vagrant
+  module Action
+    module General
+      class PackageSetupFiles
+        def initialize(app, env)
+          @app = app
+
+          env["package.include"] ||= []
+          env["package.vagrantfile"] ||= nil
+        end
+
+        def call(env)
+          files = {}
+          env["package.include"].each do |file|
+            source = Pathname.new(file)
+            dest   = nil
+
+            # If the source is relative then we add the file as-is to the include
+            # directory. Otherwise, we copy only the file into the root of the
+            # include directory. Kind of strange, but seems to match what people
+            # expect based on history.
+            if source.relative?
+              dest = source
+            else
+              dest = source.basename
+            end
+
+            # Assign the mapping
+            files[file] = dest
+          end
+
+          if env["package.vagrantfile"]
+            # Vagrantfiles are treated special and mapped to a specific file
+            files[env["package.vagrantfile"]] = "_Vagrantfile"
+          end
+
+          # Verify the mapping
+          files.each do |from, _|
+            raise Vagrant::Errors::PackageIncludeMissing,
+                  file: from if !File.exist?(from)
+          end
+
+          # Save the mapping
+          env["package.files"] = files
+
+          @app.call(env)
+        end
+      end
+    end
+  end
+end

data/lib/vagrant/action/general/package_setup_folders.rb

@@ -0,0 +1,40 @@
+# Copyright (c) HashiCorp, Inc.
+# SPDX-License-Identifier: BUSL-1.1
+
+require "fileutils"
+require_relative "package"
+
+module Vagrant
+  module Action
+    module General
+      class PackageSetupFolders
+        include Vagrant::Util::Presence
+
+        def initialize(app, env)
+          @app = app
+        end
+
+        def call(env)
+          env["package.output"] ||= "package.box"
+          env["package.directory"] ||= Dir.mktmpdir("vagrant-package-", env[:tmp_path])
+
+          # Match up a couple environmental variables so that the other parts of
+          # Vagrant will do the right thing.
+          env["export.temp_dir"] = env["package.directory"]
+
+          Vagrant::Action::General::Package.validate!(
+              env["package.output"], env["package.directory"])
+
+          @app.call(env)
+        end
+
+        def recover(env)
+          dir = env["package.directory"]
+          if File.exist?(dir)
+            FileUtils.rm_rf(dir)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/vagrant/action/hook.rb

@@ -0,0 +1,163 @@
+# Copyright (c) HashiCorp, Inc.
+# SPDX-License-Identifier: BUSL-1.1
+
+module Vagrant
+  module Action
+    # This class manages hooks into existing {Builder} stacks, and lets you
+    # add and remove middleware classes. This is the primary method by which
+    # plugins can hook into built-in middleware stacks.
+    class Hook
+      # This is a hash of the middleware to prepend to a certain
+      # other middleware.
+      #
+      # @return [Hash<Class, Array<Builder::StackItem>>]
+      attr_reader :before_hooks
+
+      # This is a hash of the middleware to append to a certain other
+      # middleware.
+      #
+      # @return [Hash<Class, Array<Builder::StackItem>>]
+      attr_reader :after_hooks
+
+      # This is a list of the hooks to just prepend to the beginning
+      #
+      # @return [Array<Builder::StackItem>]
+      attr_reader :prepend_hooks
+
+      # This is a list of the hooks to just append to the end
+      #
+      # @return [Array<Builder::StackItem>]
+      attr_reader :append_hooks
+
+      def initialize
+        @before_hooks  = Hash.new { |h, k| h[k] = [] }
+        @after_hooks   = Hash.new { |h, k| h[k] = [] }
+        @prepend_hooks = []
+        @append_hooks  = []
+      end
+
+      # Add a middleware before an existing middleware.
+      #
+      # @param [Class] existing The existing middleware.
+      # @param [Class] new The new middleware.
+      def before(existing, new, *args, **keywords, &block)
+        item = Builder::StackItem.new(
+          middleware: new,
+          arguments: Builder::MiddlewareArguments.new(
+            parameters: args,
+            keywords: keywords,
+            block: block
+          )
+        )
+        @before_hooks[existing] << item
+      end
+
+      # Add a middleware after an existing middleware.
+      #
+      # @param [Class] existing The existing middleware.
+      # @param [Class] new The new middleware.
+      def after(existing, new, *args, **keywords, &block)
+        item = Builder::StackItem.new(
+          middleware: new,
+          arguments: Builder::MiddlewareArguments.new(
+            parameters: args,
+            keywords: keywords,
+            block: block
+          )
+        )
+        @after_hooks[existing] << item
+      end
+
+      # Append a middleware to the end of the stack. Note that if the
+      # middleware sequence ends early, then the new middleware won't
+      # be run.
+      #
+      # @param [Class] new The middleware to append.
+      def append(new, *args, **keywords, &block)
+        item = Builder::StackItem.new(
+          middleware: new,
+          arguments: Builder::MiddlewareArguments.new(
+            parameters: args,
+            keywords: keywords,
+            block: block
+          )
+        )
+        @append_hooks << item
+      end
+
+      # Prepend a middleware to the beginning of the stack.
+      #
+      # @param [Class] new The new middleware to prepend.
+      def prepend(new, *args, **keywords, &block)
+        item = Builder::StackItem.new(
+          middleware: new,
+          arguments: Builder::MiddlewareArguments.new(
+            parameters: args,
+            keywords: keywords,
+            block: block
+          )
+        )
+        @prepend_hooks << item
+      end
+
+      # @return [Boolean]
+      def empty?
+        before_hooks.empty? &&
+          after_hooks.empty? &&
+          prepend_hooks.empty? &&
+          append_hooks.empty?
+      end
+
+      # This applies the given hook to a builder. This should not be
+      # called directly.
+      #
+      # @param [Builder] builder
+      def apply(builder, options={})
+        if !options[:no_prepend_or_append]
+          # Prepends first
+          @prepend_hooks.each do |item|
+            if options[:root]
+              idx = builder.index(options[:root])
+            else
+              idx = 0
+            end
+            builder.insert(idx, item.middleware, *item.arguments.parameters,
+              **item.arguments.keywords, &item.arguments.block)
+          end
+
+          # Appends
+          @append_hooks.each do |item|
+            if options[:root]
+              idx = builder.index(options[:root])
+              builder.insert(idx + 1, item.middleware, *item.arguments.parameters,
+                **item.arguments.keywords, &item.arguments.block)
+            else
+              builder.use(item.middleware, *item.arguments.parameters,
+                **item.arguments.keywords, &item.arguments.block)
+            end
+          end
+        end
+
+        # Before hooks
+        @before_hooks.each do |key, list|
+          next if !builder.index(key)
+
+          list.each do |item|
+            builder.insert_before(key, item.middleware, *item.arguments.parameters,
+              **item.arguments.keywords, &item.arguments.block)
+          end
+        end
+
+        # After hooks
+        @after_hooks.each do |key, list|
+          next if !builder.index(key)
+
+          list.each do |item|
+            builder.insert_after(key, item.middleware, *item.arguments.parameters,
+              **item.arguments.keywords, &item.arguments.block)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/vagrant/action/primary_runner.rb

@@ -0,0 +1,18 @@
+# Copyright (c) HashiCorp, Inc.
+# SPDX-License-Identifier: BUSL-1.1
+
+module Vagrant
+  module Action
+    # A PrimaryRunner is a special kind of "top-level" Action::Runner - it
+    # informs any Action::Builders it interacts with that they are also
+    # primary. This allows Builders to distinguish whether or not they are
+    # nested, which they need to know for proper action_hook handling.
+    #
+    # @see Vagrant::Action::Builder#primary
+    class PrimaryRunner < Runner
+      def primary?
+        true
+      end
+    end
+  end
+end

data/lib/vagrant/action/runner.rb

@@ -0,0 +1,112 @@
+# Copyright (c) HashiCorp, Inc.
+# SPDX-License-Identifier: BUSL-1.1
+
+require 'log4r'
+
+require 'vagrant/action/hook'
+require 'vagrant/util/busy'
+require 'vagrant/util/experimental'
+
+module Vagrant
+  module Action
+    class Runner
+      @@reported_interrupt = false
+
+      # @param globals [Hash] variables for the env to be passed to the action
+      # @yieldreturn [Hash] lazy-loaded vars merged into the env before action run
+      def initialize(globals=nil, &block)
+        @globals      = globals || {}
+        @lazy_globals = block
+        @logger       = Log4r::Logger.new("vagrant::action::runner")
+      end
+
+      # @see PrimaryRunner
+      # @see Vagrant::Action::Builder#primary
+      def primary?
+        false
+      end
+
+      def run(callable_id, options=nil)
+        callable = callable_id
+        if !callable.kind_of?(Builder)
+          if callable_id.kind_of?(Class) || callable_id.respond_to?(:call)
+            callable = Builder.build(callable_id)
+          end
+        end
+
+        if !callable || !callable.respond_to?(:call)
+          raise ArgumentError,
+            "Argument to run must be a callable object or registered action."
+        end
+
+        if callable.is_a?(Builder)
+          callable.primary = self.primary?
+        end
+
+        # Create the initial environment with the options given
+        environment = {}
+        environment.merge!(@globals)
+        environment.merge!(@lazy_globals.call) if @lazy_globals
+        environment.merge!(options || {})
+
+        # NOTE: Triggers are initialized later in the Action::Runer because of
+        # how `@lazy_globals` are evaluated. Rather than trying to guess where
+        # the `env` is coming from, we can wait until they're merged into a single
+        # hash above.
+        env = environment[:env]
+        machine = environment[:machine]
+
+        environment[:triggers] = machine.triggers if machine
+
+        if env
+          ui = Vagrant::UI::Prefixed.new(env.ui, "vagrant")
+          environment[:triggers] ||= Vagrant::Plugin::V2::Trigger.
+            new(env, env.vagrantfile.config.trigger, machine, ui)
+        end
+
+        # Run the action chain in a busy block, marking the environment as
+        # interrupted if a SIGINT occurs, and exiting cleanly once the
+        # chain has been run.
+        ui = environment[:ui] if environment.key?(:ui)
+        int_callback = lambda do
+          if environment[:interrupted]
+            if ui
+              begin
+                ui.error I18n.t("vagrant.actions.runner.exit_immediately")
+              rescue ThreadError
+                # We're being called in a trap-context. Wrap in a thread.
+                Thread.new {
+                  ui.error I18n.t("vagrant.actions.runner.exit_immediately")
+                }.join(THREAD_MAX_JOIN_TIMEOUT)
+              end
+            end
+            abort
+          end
+
+          if ui && !@@reported_interrupt
+            begin
+              ui.warn I18n.t("vagrant.actions.runner.waiting_cleanup")
+            rescue ThreadError
+              # We're being called in a trap-context. Wrap in a thread.
+              Thread.new {
+                ui.warn I18n.t("vagrant.actions.runner.waiting_cleanup")
+              }.join(THREAD_MAX_JOIN_TIMEOUT)
+            end
+          end
+          environment[:interrupted] = true
+          @@reported_interrupt = true
+        end
+
+        action_name = environment[:action_name]
+
+        # We place a process lock around every action that is called
+        @logger.info("Running action: #{action_name} #{callable_id}")
+        Util::Busy.busy(int_callback) { callable.call(environment) }
+
+        # Return the environment in case there are things in there that
+        # the caller wants to use.
+        environment
+      end
+    end
+  end
+end