vagrant 1.5.0 → 2.4.4

data/plugins/commands/up/command.rb

@@ -0,0 +1,194 @@
+# Copyright (c) HashiCorp, Inc.
+# SPDX-License-Identifier: BUSL-1.1
+
+require 'optparse'
+require 'set'
+
+require File.expand_path("../start_mixins", __FILE__)
+
+module VagrantPlugins
+  module CommandUp
+    class Command < Vagrant.plugin("2", :command)
+      include StartMixins
+
+      def self.synopsis
+        "starts and provisions the vagrant environment"
+      end
+
+      def execute
+        options = {}
+        options[:destroy_on_error] = true
+        options[:install_provider] = true
+        options[:parallel] = true
+        options[:provision_ignore_sentinel] = false
+
+        opts = OptionParser.new do |o|
+          o.banner = "Usage: vagrant up [options] [name|id]"
+          o.separator ""
+          o.separator "Options:"
+          o.separator ""
+
+          build_start_options(o, options)
+
+          o.on("--[no-]destroy-on-error",
+               "Destroy machine if any fatal error happens (default to true)") do |destroy|
+            options[:destroy_on_error] = destroy
+          end
+
+          o.on("--[no-]parallel",
+               "Enable or disable parallelism if provider supports it") do |parallel|
+            options[:parallel] = parallel
+          end
+
+          o.on("--provider PROVIDER", String,
+               "Back the machine with a specific provider") do |provider|
+            options[:provider] = provider
+          end
+
+          o.on("--[no-]install-provider",
+               "If possible, install the provider if it isn't installed") do |p|
+            options[:install_provider] = p
+          end
+        end
+
+        # Parse the options
+        argv = parse_options(opts)
+        return if !argv
+
+        # Validate the provisioners
+        validate_provisioner_flags!(options, argv)
+
+        # Go over each VM and bring it up
+        @logger.debug("'Up' each target VM...")
+
+        # Get the names of the machines we want to bring up
+        names = argv
+        if names.empty?
+          autostart = false
+          @env.vagrantfile.machine_names_and_options.each do |n, o|
+            autostart = true if o.key?(:autostart)
+            o[:autostart] = true if !o.key?(:autostart)
+            names << n.to_s if o[:autostart]
+          end
+
+          # If we have an autostart key but no names, it means that
+          # all machines are autostart: false and we don't start anything.
+          names = nil if autostart && names.empty?
+        end
+
+        # Build up the batch job of what we'll do
+        machines = []
+        if names
+          # To prevent vagrant from attempting to validate a global vms config
+          # (which doesn't exist within the local dir) when attempting to
+          # install a machines provider, this check below will disable the
+          # install_providers function if a user gives us a machine id instead
+          # of the machines name.
+          machine_names = []
+          with_target_vms(names, provider: options[:provider]){|m| machine_names << m.name }
+          options[:install_provider] = false if !(machine_names - names).empty?
+
+          # If we're installing providers, then do that. We don't
+          # parallelize this step because it is likely the same provider
+          # anyways.
+          if options[:install_provider]
+            install_providers(names, provider: options[:provider])
+          end
+
+          @env.batch(options[:parallel]) do |batch|
+            with_target_vms(names, provider: options[:provider]) do |machine|
+              @env.ui.info(I18n.t(
+                "vagrant.commands.up.upping",
+                name: machine.name,
+                provider: machine.provider_name))
+
+              machines << machine
+
+              batch.action(machine, :up, options)
+            end
+          end
+        end
+
+        if machines.empty?
+          @env.ui.info(I18n.t("vagrant.up_no_machines"))
+          return 0
+        end
+
+        # Output the post-up messages that we have, if any
+        machines.each do |m|
+          next if !m.config.vm.post_up_message
+          next if m.config.vm.post_up_message == ""
+
+          # Add a newline to separate things.
+          @env.ui.info("", prefix: false)
+
+          m.ui.success(I18n.t(
+            "vagrant.post_up_message",
+            name: m.name.to_s,
+            message: m.config.vm.post_up_message))
+        end
+
+        # Success, exit status 0
+        0
+      end
+
+      protected
+
+      def install_providers(names, provider: nil)
+        # First create a set of all the providers we need to check for.
+        # Most likely this will be a set of one.
+        providers = Set.new
+        with_target_vms(names, provider: provider) do |machine|
+          # Check if we have this machine in the index
+          entry    = @env.machine_index.get(machine.name.to_s)
+
+          # Get the provider for this machine. This logic isn't completely
+          # straightforward. If we have a forced provider, we always use
+          # that no matter what. If we have an entry in the index (meaning
+          # the machine may be created), we use that provider no matter
+          # what since that will be used by the core. If we have none, then
+          # we ask the Vagrant env what the default provider would be and use
+          # that.
+          #
+          # Note that this logic is a bit redundant if we have "provider"
+          # set but I think its probably cleaner to put this logic in one
+          # place.
+          p = provider
+          p = entry.provider.to_sym if !p && entry
+          p = @env.default_provider(
+            machine: machine.name.to_sym, check_usable: false) if !p
+
+          # Add it to the set
+          providers.add(p)
+        end
+
+        # Go through and determine if we can install the providers
+        providers.delete_if do |name|
+          !@env.can_install_provider?(name)
+        end
+
+        # Install the providers if we have to
+        providers.each do |name|
+          # Find the provider. Ignore if we can't find it, this error
+          # will pop up later in the process.
+          parts = Vagrant.plugin("2").manager.providers[name]
+          next if !parts
+
+          # If the provider is already installed, then our work here is done
+          cls = parts[0]
+          next if cls.installed?
+
+          # Some human-friendly output
+          ui = Vagrant::UI::Prefixed.new(@env.ui, "")
+          ui.output(I18n.t(
+            "vagrant.installing_provider",
+            provider: name.to_s))
+          ui.detail(I18n.t("vagrant.installing_provider_detail"))
+
+          # Install the provider
+          @env.install_provider(name)
+        end
+      end
+    end
+  end
+end

data/plugins/commands/up/middleware/store_box_metadata.rb

@@ -0,0 +1,40 @@
+# Copyright (c) HashiCorp, Inc.
+# SPDX-License-Identifier: BUSL-1.1
+
+require "json"
+
+module VagrantPlugins
+  module CommandUp
+    # Stores metadata information about the box used
+    # for the current guest. This allows Vagrant to
+    # determine the box currently in use when the
+    # Vagrantfile is modified with a new box name or
+    # version while the guest still exists.
+    class StoreBoxMetadata
+      def initialize(app, env)
+        @app = app
+        @logger = Log4r::Logger.new("vagrant::up::storeboxmetadata")
+      end
+
+      def call(env)
+        if env[:machine].box
+          box = env[:machine].box
+          box_meta = {
+            name: box.name,
+            version: box.version,
+            provider: box.provider,
+            directory: box.directory.sub(Vagrant.user_data_path.to_s + "/", "")
+          }
+          meta_file = env[:machine].data_dir.join("box_meta")
+          @logger.debug("Writing box metadata file to #{meta_file}")
+          File.open(meta_file.to_s, "w+") do |file|
+            file.write(JSON.dump(box_meta))
+          end
+        else
+          @logger.debug("No box data found for #{env[:machine].name} with provider #{env[:machine].provider_name}")
+        end
+        @app.call(env)
+      end
+    end
+  end
+end

data/plugins/commands/up/plugin.rb

@@ -0,0 +1,25 @@
+# Copyright (c) HashiCorp, Inc.
+# SPDX-License-Identifier: BUSL-1.1
+
+require "vagrant"
+
+module VagrantPlugins
+  module CommandUp
+    class Plugin < Vagrant.plugin("2")
+      name "up command"
+      description <<-DESC
+      The `up` command brings the virtual environment up and running.
+      DESC
+
+      command("up") do
+        require File.expand_path("../command", __FILE__)
+        Command
+      end
+
+      action_hook(:store_box_metadata, :machine_action_up) do |hook|
+        require_relative "middleware/store_box_metadata"
+        hook.append(StoreBoxMetadata)
+      end
+    end
+  end
+end

data/plugins/commands/up/start_mixins.rb

@@ -0,0 +1,58 @@
+# Copyright (c) HashiCorp, Inc.
+# SPDX-License-Identifier: BUSL-1.1
+
+require "set"
+
+module VagrantPlugins
+  module CommandUp
+    module StartMixins
+      # This adds the standard `start` command line flags to the given
+      # OptionParser, storing the result in the `options` dictionary.
+      #
+      # @param [OptionParser] parser
+      # @param [Hash] options
+      def build_start_options(parser, options)
+        # Setup the defaults
+        options[:provision_types] = nil
+
+        # Add the options
+        parser.on("--[no-]provision", "Enable or disable provisioning") do |p|
+          options[:provision_enabled] = p
+          options[:provision_ignore_sentinel] = true
+        end
+
+        parser.on("--provision-with x,y,z", Array,
+                "Enable only certain provisioners, by type or by name.") do |list|
+          options[:provision_types] = list.map { |type| type.to_sym }
+          options[:provision_enabled] = true
+          options[:provision_ignore_sentinel] = true
+        end
+      end
+
+      # This validates the provisioner flags and raises an exception
+      # if there are invalid ones.
+      def validate_provisioner_flags!(options, argv)
+        if options[:provision_types].nil?
+          return
+        end
+
+        provisioner_names = Set.new
+        with_target_vms(argv) do |machine|
+          machine.config.vm.provisioners.map(&:name).each do |name|
+            provisioner_names.add(name)
+          end
+        end
+
+        if (provisioner_names & options[:provision_types]).empty?
+          (options[:provision_types] || []).each do |type|
+              klass = Vagrant.plugin("2").manager.provisioners[type]
+              if !klass
+                raise Vagrant::Errors::ProvisionerFlagInvalid,
+                  name: type.to_s
+              end
+          end
+        end
+      end
+    end
+  end
+end

data/plugins/commands/upload/command.rb

@@ -0,0 +1,239 @@
+# Copyright (c) HashiCorp, Inc.
+# SPDX-License-Identifier: BUSL-1.1
+
+require 'optparse'
+require "rubygems/package"
+
+module VagrantPlugins
+  module CommandUpload
+    class Command < Vagrant.plugin("2", :command)
+
+      VALID_COMPRESS_TYPES = [:tgz, :zip].freeze
+
+      def self.synopsis
+        "upload to machine via communicator"
+      end
+
+      def execute
+        options = {}
+
+        opts = OptionParser.new do |o|
+          o.banner = "Usage: vagrant upload [options] <source> [destination] [name|id]"
+          o.separator ""
+          o.separator "Options:"
+          o.separator ""
+
+          o.on("-t", "--temporary", "Upload source to temporary directory") do |t|
+            options[:temporary] = t
+          end
+
+          o.on("-c", "--compress", "Use gzip compression for upload") do |c|
+            options[:compress] = c
+          end
+
+          o.on("-C", "--compression-type=TYPE", "Type of compression to use (#{VALID_COMPRESS_TYPES.join(", ")})") do |c|
+            options[:compression_type] = c.to_sym
+            options[:compress] = true
+          end
+        end
+
+        argv = parse_options(opts)
+        return if !argv
+
+        case argv.size
+        when 3
+          source, destination, guest = argv
+        when 2, 1
+          source = argv[0]
+          if @env.active_machines.map(&:first).map(&:to_s).include?(argv[1])
+            guest = argv[1]
+          else
+            destination = argv[1]
+          end
+        else
+          raise Vagrant::Errors::CLIInvalidUsage, help: opts.help.chomp
+        end
+
+        # NOTE: We do this to handle paths on Windows like: "..\space dir\"
+        # because the final separator acts to escape the quote and ends up
+        # in the source value.
+        source = source.sub(/["']$/, "")
+        destination ||= File.basename(source)
+
+        if File.file?(source)
+          type = :file
+        elsif File.directory?(source)
+          type = :directory
+        else
+          raise Vagrant::Errors::UploadSourceMissing,
+            source: source
+        end
+
+        with_target_vms(guest, single_target: true) do |machine|
+          if options[:temporary]
+            if !machine.guest.capability?(:create_tmp_path)
+              raise Vagrant::Errors::UploadMissingTempCapability
+            end
+            extension = File.extname(source) if type == :file
+            destination = machine.guest.capability(:create_tmp_path, type: type, extension: extension)
+          end
+
+          if options[:compress]
+            compression_setup!(machine, options)
+            @env.ui.info(I18n.t("vagrant.commands.upload.compress",
+              source: source,
+              type: options[:compression_type]
+            ))
+            destination_decompressed = destination
+            destination = machine.guest.capability(:create_tmp_path, type: :file, extension: ".#{options[:compression_type]}")
+            source_display = source
+            source = options[:compression_type] == :zip ? compress_source_zip(source) : compress_source_tgz(source)
+          end
+
+          @env.ui.info(I18n.t("vagrant.commands.upload.start",
+            source: source,
+            destination: destination
+          ))
+
+          # If the source is a directory, attach a `/.` to the end so we
+          # upload the contents to the destination instead of within a
+          # folder at the destination
+          if File.directory?(source) && !source.end_with?(".")
+            upload_source = File.join(source, ".")
+          else
+            upload_source = source
+          end
+
+          machine.communicate.upload(upload_source, destination)
+
+          if options[:compress]
+            @env.ui.info(I18n.t("vagrant.commands.upload.decompress",
+              destination: destination_decompressed,
+              type: options[:compression_type]
+            ))
+            machine.guest.capability(options[:decompression_method], destination, destination_decompressed, type: type)
+            destination = destination_decompressed
+            FileUtils.rm(source)
+            source = source_display
+          end
+        end
+
+        @env.ui.info(I18n.t("vagrant.commands.upload.complete",
+          source: source,
+          destination: destination
+        ))
+
+        # Success, exit status 0
+        0
+      end
+
+      # Setup compression options and validate host and guest have capability
+      # to handle compression
+      #
+      # @param [Vagrant::Machine] machine Vagrant guest machine
+      # @param [Hash] options Command options
+      def compression_setup!(machine, options)
+        if !options[:compression_type]
+          if machine.guest.capability_host_chain.first[0] == :windows
+            options[:compression_type] = :zip
+          else
+            options[:compression_type] = :tgz
+          end
+        end
+        if !VALID_COMPRESS_TYPES.include?(options[:compression_type])
+          raise Vagrant::Errors::UploadInvalidCompressionType,
+            type: options[:compression_type],
+            valid_types: VALID_COMPRESS_TYPES.join(", ")
+        end
+        options[:decompression_method] = "decompress_#{options[:compression_type]}".to_sym
+        if !machine.guest.capability?(options[:decompression_method])
+          raise Vagrant::Errors::UploadMissingExtractCapability,
+            type: options[:compression_type]
+        end
+      end
+
+      # Compress path using zip into temporary file
+      #
+      # @param [String] path Path to compress
+      # @return [String] path to compressed file
+      def compress_source_zip(path)
+        require "zip"
+        zipfile = Tempfile.create(["vagrant", ".zip"])
+        zipfile.close
+        if File.file?(path)
+          source_items = [path]
+        else
+          source_items = Dir.glob(File.join(path, "**", "**", "*"))
+        end
+        c_dir = nil
+        Zip::File.open(zipfile.path, Zip::File::CREATE) do |zip|
+          source_items.each do |source_item|
+            next if File.directory?(source_item)
+            trim_item = source_item.sub(path, "").sub(%r{^[/\\]}, "")
+            dirname = File.dirname(trim_item)
+            zip.mkdir dirname if c_dir != dirname
+            c_dir = dirname
+            zip.get_output_stream(trim_item) do |f|
+              source_file = File.open(source_item, "rb")
+              while data = source_file.read(2048)
+                f.write(data)
+              end
+            end
+          end
+        end
+        zipfile.path
+      end
+
+      # Compress path using tar and gzip into temporary file
+      #
+      # @param [String] path Path to compress
+      # @return [String] path to compressed file
+      def compress_source_tgz(path)
+        tarfile = Tempfile.create(["vagrant", ".tar"])
+        tarfile.close
+        tarfile = File.open(tarfile.path, "wb+")
+        tgzfile = Tempfile.create(["vagrant", ".tgz"])
+        tgzfile.close
+        tgzfile = File.open(tgzfile.path, "wb")
+        tar = Gem::Package::TarWriter.new(tarfile)
+        tgz = Zlib::GzipWriter.new(tgzfile)
+        if File.file?(path)
+          tar.add_file(File.basename(path), File.stat(path).mode) do |io|
+            File.open(path, "rb") do |file|
+              while bytes = file.read(4096)
+                io.write(bytes)
+              end
+            end
+          end
+        else
+          Dir.glob(File.join(path, "**/**/*")).each do |item|
+            rel_path = item.sub(path, "")
+            item_mode = File.stat(item).mode
+
+            if File.directory?(item)
+              tar.mkdir(rel_path, item_mode)
+            else
+              tar.add_file(rel_path, item_mode) do |io|
+                File.open(item, "rb") do |file|
+                  while bytes = file.read(4096)
+                    io.write(bytes)
+                  end
+                end
+              end
+            end
+          end
+        end
+        tar.close
+        tarfile.rewind
+        while bytes = tarfile.read(4096)
+          tgz.write bytes
+        end
+        tgz.close
+        tgzfile.close
+        tarfile.close
+        File.delete(tarfile.path)
+        tgzfile.path
+      end
+    end
+  end
+end

data/plugins/commands/upload/plugin.rb

@@ -0,0 +1,20 @@
+# Copyright (c) HashiCorp, Inc.
+# SPDX-License-Identifier: BUSL-1.1
+
+require "vagrant"
+
+module VagrantPlugins
+  module CommandUpload
+    class Plugin < Vagrant.plugin("2")
+      name "upload command"
+      description <<-DESC
+      The `upload` command uploads files to guest via communicator
+      DESC
+
+      command("upload") do
+        require File.expand_path("../command", __FILE__)
+        Command
+      end
+    end
+  end
+end

data/plugins/commands/validate/command.rb

@@ -0,0 +1,107 @@
+# Copyright (c) HashiCorp, Inc.
+# SPDX-License-Identifier: BUSL-1.1
+
+require 'optparse'
+
+module VagrantPlugins
+  module CommandValidate
+    class Command < Vagrant.plugin("2", :command)
+      def self.synopsis
+        "validates the Vagrantfile"
+      end
+
+      def execute
+        options = {}
+
+        opts = OptionParser.new do |o|
+          o.banner = "Usage: vagrant validate [options]"
+          o.separator ""
+          o.separator "Validates a Vagrantfile config"
+          o.separator ""
+          o.separator "Options:"
+          o.separator ""
+
+          o.on("-p", "--ignore-provider", "Ignores provider config options") do |p|
+            options[:ignore_provider] = p
+          end
+        end
+
+        # Parse the options
+        argv = parse_options(opts)
+        return if !argv
+
+        action_env = {}
+        if options[:ignore_provider]
+          action_env[:ignore_provider] = true
+          tmp_data_dir = mockup_providers!
+        end
+
+        # Validate the configuration of all machines
+        with_target_vms() do |machine|
+          machine.action_raw(:config_validate, Vagrant::Action::Builtin::ConfigValidate, action_env)
+        end
+
+        @env.ui.info(I18n.t("vagrant.commands.validate.success"))
+
+        # Success, exit status 0
+        0
+      ensure
+        FileUtils.remove_entry tmp_data_dir if tmp_data_dir
+      end
+
+      protected
+
+      # This method is required to bypass some of the provider checks that would
+      # otherwise raise exceptions before Vagrant could load and validate a config.
+      # It essentially ignores that there are no installed or usable prodivers so
+      # that Vagrant can go along and validate the rest of the Vagrantfile and ignore
+      # any provider blocks.
+      #
+      # return [String] tmp_data_dir - Temporary dir used to store guest metadata during validation
+      def mockup_providers!
+        require 'log4r'
+        logger = Log4r::Logger.new("vagrant::validate")
+        logger.debug("Overriding all registered provider classes for validate")
+
+        # Without setting up a tmp Environment, Vagrant will completely
+        # erase the local data dotfile and you can lose state after the
+        # validate command completes.
+        tmp_data_dir = Dir.mktmpdir("vagrant-validate-")
+        @env = Vagrant::Environment.new(
+          cwd: @env.cwd,
+          home_path: @env.home_path,
+          ui_class: @env.ui_class,
+          vagrantfile_name: @env.vagrantfile_name,
+          local_data_path: tmp_data_dir,
+          data_dir: tmp_data_dir
+        )
+
+        Vagrant.plugin("2").manager.providers.each do |key, data|
+          data[0].class_eval do
+            def initialize(machine)
+            end
+
+            def machine_id_changed
+            end
+
+            def self.installed?
+              true
+            end
+
+            def self.usable?(raise_error=false)
+              true
+            end
+
+            def state
+              state_id = Vagrant::MachineState::NOT_CREATED_ID
+              short = :not_created
+              long = :not_created
+              Vagrant::MachineState.new(state_id, short, long)
+            end
+          end
+        end
+        tmp_data_dir
+      end
+    end
+  end
+end