vagrant 1.5.0 → 2.4.4

data/Gemfile

@@ -1,4 +1,12 @@
-source 'https://rubygems.org'
+# Copyright (c) HashiCorp, Inc.
+# SPDX-License-Identifier: BUSL-1.1
+
+source "https://rubygems.org"
 
-# Specify your gem's dependencies in vagrant-stub.gemspec
 gemspec
+
+if File.exist?(File.expand_path("../../vagrant-spec", __FILE__))
+  gem 'vagrant-spec', path: "../vagrant-spec"
+else
+  gem 'vagrant-spec', git: "https://github.com/hashicorp/vagrant-spec.git", branch: :main
+end

data/LICENSE

@@ -0,0 +1,92 @@
+License text copyright (c) 2020 MariaDB Corporation Ab, All Rights Reserved.
+"Business Source License" is a trademark of MariaDB Corporation Ab.
+
+Parameters
+
+Licensor:             HashiCorp, Inc.
+Licensed Work:        Vagrant 2.4.3 or later. The Licensed Work is (c) 2024
+                      HashiCorp, Inc.
+Additional Use Grant: You may make production use of the Licensed Work, provided
+                      Your use does not include offering the Licensed Work to third
+                      parties on a hosted or embedded basis in order to compete with
+                      HashiCorp’s paid version(s) of the Licensed Work. For purposes
+                      of this license:
+
+                      A "competitive offering" is a Product that is offered to third
+                      parties on a paid basis, including through paid support
+                      arrangements, that significantly overlaps with the capabilities
+                      of HashiCorp's paid version(s) of the Licensed Work. If Your
+                      Product is not a competitive offering when You first make it
+                      generally available, it will not become a competitive offering
+                      later due to HashiCorp releasing a new version of the Licensed
+                      Work with additional capabilities. In addition, Products that
+                      are not provided on a paid basis are not competitive.
+
+                      "Product" means software that is offered to end users to manage
+                      in their own environments or offered as a service on a hosted
+                      basis.
+
+                      "Embedded" means including the source code or executable code
+                      from the Licensed Work in a competitive offering. "Embedded"
+                      also means packaging the competitive offering in such a way
+                      that the Licensed Work must be accessed or downloaded for the
+                      competitive offering to operate.
+
+                      Hosting or using the Licensed Work(s) for internal purposes
+                      within an organization is not considered a competitive
+                      offering. HashiCorp considers your organization to include all
+                      of your affiliates under common control.
+
+                      For binding interpretive guidance on using HashiCorp products
+                      under the Business Source License, please visit our FAQ.
+                      (https://www.hashicorp.com/license-faq)
+Change Date:          Four years from the date the Licensed Work is published.
+Change License:       MPL 2.0
+
+For information about alternative licensing arrangements for the Licensed Work,
+please contact licensing@hashicorp.com.
+
+Notice
+
+Business Source License 1.1
+
+Terms
+
+The Licensor hereby grants you the right to copy, modify, create derivative
+works, redistribute, and make non-production use of the Licensed Work. The
+Licensor may make an Additional Use Grant, above, permitting limited production use.
+
+Effective on the Change Date, or the fourth anniversary of the first publicly
+available distribution of a specific version of the Licensed Work under this
+License, whichever comes first, the Licensor hereby grants you rights under
+the terms of the Change License, and the rights granted in the paragraph
+above terminate.
+
+If your use of the Licensed Work does not comply with the requirements
+currently in effect as described in this License, you must purchase a
+commercial license from the Licensor, its affiliated entities, or authorized
+resellers, or you must refrain from using the Licensed Work.
+
+All copies of the original and modified Licensed Work, and derivative works
+of the Licensed Work, are subject to this License. This License applies
+separately for each version of the Licensed Work and the Change Date may vary
+for each version of the Licensed Work released by Licensor.
+
+You must conspicuously display this License on each original or modified copy
+of the Licensed Work. If you receive the Licensed Work in original or
+modified form from a third party, the terms and conditions set forth in this
+License apply to your use of that work.
+
+Any use of the Licensed Work in violation of this License will automatically
+terminate your rights under this License for the current and all other
+versions of the Licensed Work.
+
+This License does not grant you any right in any trademark or logo of
+Licensor or its affiliates (provided that you may use a trademark or logo of
+Licensor as expressly required by this License).
+
+TO THE EXTENT PERMITTED BY APPLICABLE LAW, THE LICENSED WORK IS PROVIDED ON
+AN "AS IS" BASIS. LICENSOR HEREBY DISCLAIMS ALL WARRANTIES AND CONDITIONS,
+EXPRESS OR IMPLIED, INCLUDING (WITHOUT LIMITATION) WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE, NON-INFRINGEMENT, AND
+TITLE.

data/README.md

@@ -1,4 +1,56 @@
-# Vagrant Stub
+# Vagrant
 
-This is a stub gem that is now uploaded to RubyGems to point people
-to the installers for Vagrant.
+- Website: [https://www.vagrantup.com/](https://www.vagrantup.com/)
+- Source: [https://github.com/hashicorp/vagrant](https://github.com/hashicorp/vagrant)
+- HashiCorp Discuss: [https://discuss.hashicorp.com/c/vagrant/24](https://discuss.hashicorp.com/c/vagrant/24)
+
+Vagrant is a tool for building and distributing development environments.
+
+Development environments managed by Vagrant can run on local virtualized
+platforms such as VirtualBox or VMware, in the cloud via AWS or OpenStack,
+or in containers such as with Docker or raw LXC.
+
+Vagrant provides the framework and configuration format to create and
+manage complete portable development environments. These development
+environments can live on your computer or in the cloud, and are portable
+between Windows, Mac OS X, and Linux.
+
+## Quick Start
+
+Package dependencies: Vagrant requires `bsdtar` and `curl` to be available on
+your system PATH to run successfully.
+
+For the quick-start, we'll bring up a development machine on
+[VirtualBox](https://www.virtualbox.org/) because it is free and works
+on all major platforms. Vagrant can, however, work with almost any
+system such as [OpenStack](https://www.openstack.org/), [VMware](https://www.vmware.com/), [Docker](https://docs.docker.com/), etc.
+
+First, make sure your development machine has
+[VirtualBox](https://www.virtualbox.org/)
+installed. After this,
+[download and install the appropriate Vagrant package for your OS](https://www.vagrantup.com/downloads.html).
+
+To build your first virtual environment:
+
+    vagrant init hashicorp/bionic64
+    vagrant up
+
+Note: The above `vagrant up` command will also trigger Vagrant to download the
+`bionic64` box via the specified URL. Vagrant only does this if it detects that
+the box doesn't already exist on your system.
+
+## Getting Started Guide
+
+To learn how to build a fully functional development environment, follow the
+[getting started guide](https://www.vagrantup.com/docs/getting-started).
+
+## Installing from Source
+
+If you want the bleeding edge version of Vagrant, we try to keep main pretty stable
+and you're welcome to give it a shot. Please review the installation page [here](https://www.vagrantup.com/docs/installation/source).
+
+## Contributing to Vagrant
+
+Please take time to read the [HashiCorp Community Guidelines](https://www.hashicorp.com/community-guidelines) and the [Vagrant Contributing Guide](https://github.com/hashicorp/vagrant/blob/main/.github/CONTRIBUTING.md).
+
+Then you're good to go!

data/RELEASE.md

@@ -0,0 +1,11 @@
+# Releasing Vagrant
+
+This documents how to release Vagrant. Various steps in this document will
+require privileged access to private systems, so this document is only
+targeted at Vagrant core members who have the ability to cut a release.
+
+1. Go to the [release initiator workflow](https://github.com/hashicorp/vagrant/actions/workflows/initiate-release.yml)
+
+1. Trigger a new run with the version to be released (it should not include a `v` prefix, for example: `1.0.0`)
+
+1. After release is complete, update [Checkpoint](https://checkpoint.hashicorp.com/control)

data/Rakefile

@@ -1 +1,22 @@
-require "bundler/gem_tasks"
+require 'rubygems'
+require 'bundler/setup'
+require "rake/extensiontask"
+
+# Immediately sync all stdout so that tools like buildbot can
+# immediately load in the output.
+$stdout.sync = true
+$stderr.sync = true
+
+Rake::ExtensionTask.new "vagrant/vagrant_ssl" do |ext|
+end
+
+# Load all the rake tasks from the "tasks" folder. This folder
+# allows us to nicely separate rake tasks into individual files
+# based on their role, which makes development and debugging easier
+# than one monolithic file.
+task_dir = File.expand_path("../tasks", __FILE__)
+Dir["#{task_dir}/**/*.rake"].each do |task_file|
+  load task_file
+end
+
+task default: "test:unit"

data/Vagrantfile

@@ -0,0 +1,31 @@
+# This Vagrantfile can be used to develop Vagrant. Note that VirtualBox
+# doesn't run in VirtualBox so you can't actually _run_ Vagrant within
+# the VM created by this Vagrantfile, but you can use it to develop the
+# Ruby, run unit tests, etc.
+
+Vagrant.configure("2") do |config|
+  config.vm.box = "hashicorp/bionic64"
+  config.vm.hostname = "vagrant"
+  config.ssh.shell = "bash -c 'BASH_ENV=/etc/profile exec bash'"
+
+  ["vmware_desktop", "virtualbox", "hyperv"].each do |provider|
+    config.vm.provider provider do |v, override|
+      v.memory = "2048"
+    end
+  end
+
+  # We split apart `install_rvm` from `setup_tests` because rvm says to
+  # logout and log back in just after installing RVM.
+  # https://github.com/rvm/ubuntu_rvm#3-reboot
+  config.vm.provision "shell", path: "scripts/install_rvm"
+
+  config.vm.provision "shell", path: "scripts/setup_tests"
+
+  config.push.define "www", strategy: "local-exec" do |push|
+    push.script = "scripts/website_push_www.sh"
+  end
+
+  config.push.define "docs", strategy: "local-exec" do |push|
+    push.script = "scripts/website_push_docs.sh"
+  end
+end

data/bin/vagrant

@@ -1,4 +1,270 @@
 #!/usr/bin/env ruby
 
-$stderr.puts File.read(File.expand_path("../../message.txt", __FILE__))
-abort
+# Trap interrupts to quit cleanly. This will be overridden at some point
+# by Vagrant. This is made to catch any interrupts while Vagrant is
+# initializing which have historically resulted in stack traces.
+Signal.trap("INT") { abort }
+
+# Disable exception reporting by default if available
+if Thread.respond_to?(:report_on_exception=)
+  Thread.report_on_exception = false
+end
+
+# Split arguments by "--" if its there, we'll recombine them later
+argv = ARGV.dup
+argv_extra = []
+
+# These will be the options that are passed to initialize the Vagrant
+# environment.
+opts = {}
+
+if idx = argv.index("--")
+  argv_extra = argv.slice(idx+1, argv.length-2)
+  argv = argv.slice(0, idx)
+end
+
+require_relative "../lib/vagrant/version"
+# Fast path the version of Vagrant
+if argv.include?("-v") || argv.include?("--version")
+  puts "Vagrant #{Vagrant::VERSION}"
+  exit 0
+end
+
+# Disable plugin loading for commands where plugins are not required. This will
+# also disable loading of the Vagrantfile if it available as the environment
+# is not required for these commands
+argv.each_index do |i|
+  arg = argv[i]
+
+  if !arg.start_with?("-")
+    if arg == "box" && argv[i+1] == "list"
+      opts[:vagrantfile_name] = ""
+      ENV['VAGRANT_NO_PLUGINS'] = "1"
+    end
+
+    # Do not load plugins when performing plugin operations
+    if arg == "plugin"
+      if argv.none?{|a| a == "--local" } && !ENV["VAGRANT_LOCAL_PLUGINS_LOAD"]
+        opts[:vagrantfile_name] = ""
+      end
+      ENV['VAGRANT_NO_PLUGINS'] = "1"
+      # Only initialize plugins when listing installed plugins
+      if argv[i+1] != "list"
+        ENV['VAGRANT_DISABLE_PLUGIN_INIT'] = "1"
+      end
+    end
+
+    break
+  end
+end
+
+# Set logging level to `debug`. This is done before loading 'vagrant', as it
+# sets up the logging system.
+if argv.include?("--debug")
+  argv.delete("--debug")
+  ENV["VAGRANT_LOG"] = "debug"
+end
+
+# Enable log timestamps if requested
+if argv.include?("--timestamp")
+  argv.delete("--timestamp")
+  ENV["VAGRANT_LOG_TIMESTAMP"] = "1"
+end
+
+# Convenience flag to enable debug with timestamps
+if argv.include?("--debug-timestamp")
+  argv.delete("--debug-timestamp")
+  ENV["VAGRANT_LOG"] = "debug"
+  ENV["VAGRANT_LOG_TIMESTAMP"] = "1"
+end
+
+# Stdout/stderr should not buffer output
+$stdout.sync = true
+$stderr.sync = true
+
+# Before we start activate all our dependencies
+# so we can provide correct resolutions later
+builtin_specs = []
+
+vagrant_spec = Gem::Specification.find_all_by_name("vagrant").detect do |spec|
+  spec.version == Gem::Version.new(Vagrant::VERSION)
+end
+
+dep_activator = proc do |spec|
+  spec.runtime_dependencies.each do |dep|
+    gem(dep.name, *dep.requirement.as_list)
+    dep_spec = Gem::Specification.find_all_by_name(dep.name).detect(&:activated?)
+    if dep_spec
+      builtin_specs << dep_spec
+      dep_activator.call(dep_spec)
+    end
+  end
+end
+
+if vagrant_spec
+  dep_activator.call(vagrant_spec)
+end
+
+env = nil
+begin
+  require 'vagrant'
+  require 'vagrant/bundler'
+  require 'vagrant/cli'
+  require 'vagrant/util/platform'
+  require 'vagrant/util/experimental'
+
+  # Set our list of builtin specs
+  Vagrant::Bundler.instance.builtin_specs = builtin_specs
+
+  # Schedule the cleanup of things
+  at_exit(&Vagrant::Bundler.instance.method(:deinit))
+
+  # If this is not a pre-release disable verbose output
+  if !Vagrant.prerelease?
+    $VERBOSE = nil
+  end
+
+  # Add any option flags defined within this file here
+  # so they are automatically propagated to all commands
+  Vagrant.add_default_cli_options(proc { |o|
+    o.on("--[no-]color", "Enable or disable color output")
+    o.on("--machine-readable", "Enable machine readable output")
+    o.on("-v", "--version", "Display Vagrant version")
+    o.on("--debug", "Enable debug output")
+    o.on("--timestamp", "Enable timestamps on log output")
+    o.on("--debug-timestamp", "Enable debug output with timestamps")
+    o.on("--no-tty", "Enable non-interactive output")
+  })
+
+  # Create a logger right away
+  logger = Log4r::Logger.new("vagrant::bin::vagrant")
+  logger.info("`vagrant` invoked: #{ARGV.inspect}")
+
+  # Disable color in a few cases:
+  #
+  #   * --no-color is anywhere in our arguments
+  #   * STDOUT is not a TTY
+  #   * The terminal doesn't support colors (Windows)
+  #
+  if argv.include?("--no-color") || ENV["VAGRANT_NO_COLOR"]
+    # Delete the argument from the list so that it doesn't
+    # cause any invalid arguments down the road.
+    argv.delete("--no-color")
+
+    opts[:ui_class] = Vagrant::UI::Basic
+  elsif !Vagrant::Util::Platform.terminal_supports_colors?
+    opts[:ui_class] = Vagrant::UI::Basic
+  elsif !$stdout.tty? && !Vagrant::Util::Platform.cygwin?
+    # Cygwin always reports STDOUT is not a TTY, so we only disable
+    # colors if its not a TTY AND its not Cygwin.
+    opts[:ui_class] = Vagrant::UI::Basic
+  end
+
+  # Also allow users to force colors.
+  if argv.include?("--color") || ENV["VAGRANT_FORCE_COLOR"]
+    argv.delete("--color")
+    opts[:ui_class] = Vagrant::UI::Colored
+  end
+
+  # Highest precedence is if we have enabled machine-readable output
+  if argv.include?("--machine-readable")
+    argv.delete("--machine-readable")
+    opts[:ui_class] = Vagrant::UI::MachineReadable
+  end
+
+  # Setting to enable/disable showing progress bars
+  if argv.include?("--no-tty")
+    argv.delete("--no-tty")
+    opts[:ui_class] = Vagrant::UI::NonInteractive
+  end
+
+  # Default to colored output
+  opts[:ui_class] ||= Vagrant::UI::Colored
+
+  # Recombine the arguments
+  if !argv_extra.empty?
+    argv << "--"
+    argv += argv_extra
+  end
+
+  # Create the environment, which is the cwd of wherever the
+  # `vagrant` command was invoked from
+  logger.debug("Creating Vagrant environment")
+  env = Vagrant::Environment.new(opts)
+
+  # If we are running with the Windows Subsystem for Linux do
+  # some extra setup to allow access to Vagrant managed machines
+  # outside the subsystem
+  if Vagrant::Util::Platform.wsl?
+    recreate_env = Vagrant::Util::Platform.wsl_init(env, logger)
+    if recreate_env
+      logger.info("Re-creating Vagrant environment due to WSL modifications.")
+      env = Vagrant::Environment.new(opts)
+    end
+  end
+
+  # If not being run from the installer, check if expected tools
+  # are available.
+  if !Vagrant.in_installer?
+    missing_tools = Vagrant.detect_missing_tools
+
+    if !missing_tools.empty?
+      env.ui.warn(
+        I18n.t("vagrant.general.not_in_installer", tools: missing_tools.sort.join(", ")) + "\n",
+        prefix: false
+      )
+    end
+  end
+
+  # Acceptable experimental flag values include:
+  #
+  # Unset  - Disables experimental features
+  # 0      - Disables experimental features
+  # 1      - Enables all features
+  # String - Enables one or more features, separated by commas
+  if Vagrant::Util::Experimental.enabled?
+    experimental = Vagrant::Util::Experimental.features_requested
+    ui = Vagrant::UI::Prefixed.new(env.ui, "vagrant")
+    logger.debug("Experimental flag is enabled")
+    if Vagrant::Util::Experimental.global_enabled?
+      ui.warn(I18n.t("vagrant.general.experimental.all"), bold: true, prefix: true, channel: :error)
+    else
+      ui.warn(I18n.t("vagrant.general.experimental.features", features: experimental.join(", ")), bold: true, prefix: true, channel: :error)
+    end
+  end
+
+  begin
+    # Execute the CLI interface, and exit with the proper error code
+    exit_status = env.cli(argv)
+  ensure
+    # Unload the environment so cleanup can be done
+    env.unload
+  end
+
+  # Exit with the exit status from our CLI command
+  exit(exit_status)
+rescue Exception => e
+  # It is possible for errors to happen in Vagrant's initialization. In
+  # this case, we don't have access to this class yet, so we check for it.
+  raise if !defined?(Vagrant) || !defined?(Vagrant::Errors)
+  raise if !e.is_a?(Vagrant::Errors::VagrantError)
+
+  require 'log4r'
+  logger = Log4r::Logger.new("vagrant::bin::vagrant")
+  logger.error("Vagrant experienced an error! Details:")
+  logger.error(e.inspect)
+  logger.error(e.message)
+  logger.error(e.backtrace.join("\n"))
+
+  if env
+    opts = { prefix: false }
+    env.ui.error(e.message, **opts) if e.message
+    env.ui.machine("error-exit", e.class.to_s, e.message.to_s)
+  else
+    $stderr.puts "Vagrant failed to initialize at a very early stage:\n\n"
+    $stderr.puts e.message
+  end
+
+  exit e.status_code if e.respond_to?(:status_code)
+  exit 255 # An error occurred with no status code defined
+end

data/contrib/README.md

@@ -0,0 +1,17 @@
+# Vagrant Contrib
+
+Miscellaneous contributions which assist people in using Vagrant will
+make their way into this directory. An up-to-date list of short descriptions
+for each item will be kept below.
+
+## List of Contrib Items
+
+* `bash` - Contains a bash script for improving autocompletion with bash.
+* `emacs` - Contains a file for enabling Ruby syntax highlighting for `Vagrantfile`s in `emacs`.
+* `st` - Contains a `.sublime-settings` file for enabling Ruby syntax highlighting
+  for `Vagrantfile`s in Sublime Text.
+* `sudoers` - Contains the pieces of `/etc/sudoers` configuration to avoid password entry when
+  starting machines.
+* `vim` - Contains a `.vim` file for enabling Ruby syntax highlighting
+  for `Vagrantfile`s in `vim`.
+* `zsh` - Contains a zsh script for improving autocompletion with zsh.