vagrant 1.5.0 → 2.4.4

data/plugins/kernel_v2/config/cloud_init.rb

@@ -0,0 +1,136 @@
+# Copyright (c) HashiCorp, Inc.
+# SPDX-License-Identifier: BUSL-1.1
+
+require "log4r"
+require "securerandom"
+
+module VagrantPlugins
+  module Kernel_V2
+    class VagrantConfigCloudInit < Vagrant.plugin("2", :config)
+      #-------------------------------------------------------------------
+      # Config class for cloud-init
+      #-------------------------------------------------------------------
+
+      DEFAULT_CONTENT_TYPES = ["text/cloud-boothook", "text/cloud-config",
+                               "text/cloud-config-archive", "text/jinja2",
+                               "text/part-handler", "text/upstart-job",
+                               "text/x-include-once-url", "text/x-include-url",
+                               "text/x-shellscript"].map(&:freeze).freeze
+
+      DEFAULT_CONFIG_TYPE = :user_data
+
+      # @note This value is for internal use only
+      #
+      # @return [String]
+      attr_reader :id
+
+      # The 'type' of data being stored. If not defined,
+      # will default to :user_data
+      #
+      # @return [Symbol]
+      attr_accessor :type
+
+      # @return [String]
+      attr_accessor :content_type
+
+      # The optional mime-part content-disposition filename.
+      #
+      # @return [String]
+      attr_accessor :content_disposition_filename
+
+      # @return [String]
+      attr_accessor :path
+
+      # @return [String]
+      attr_accessor :inline
+
+      def initialize(type=nil)
+        @logger = Log4r::Logger.new("vagrant::config::vm::cloud_init")
+
+        @type = type if type
+
+        @content_type = UNSET_VALUE
+        @content_disposition_filename = UNSET_VALUE
+        @path = UNSET_VALUE
+        @inline = UNSET_VALUE
+
+        # Internal options
+        @id = SecureRandom.uuid
+      end
+
+      def finalize!
+        if !@type
+          @type = DEFAULT_CONFIG_TYPE
+        else
+          @type = @type.to_sym
+        end
+
+        @content_type = nil if @content_type == UNSET_VALUE
+        @content_disposition_filename = nil if @content_disposition_filename == UNSET_VALUE
+        @path = nil if @path == UNSET_VALUE
+        @inline = nil if @inline == UNSET_VALUE
+      end
+
+      # @return [Array] array of strings of error messages from config option validation
+      def validate(machine)
+        errors = _detected_errors
+
+        if @type && @type != DEFAULT_CONFIG_TYPE
+          errors << I18n.t("vagrant.cloud_init.incorrect_type_set",
+                           type: @type,
+                           machine: machine.name,
+                           default_type: DEFAULT_CONFIG_TYPE)
+        end
+
+        if !@content_type
+          errors << I18n.t("vagrant.cloud_init.content_type_not_set",
+                           machine: machine.name,
+                           accepted_types: DEFAULT_CONTENT_TYPES.join(', '))
+        elsif !DEFAULT_CONTENT_TYPES.include?(@content_type)
+          errors << I18n.t("vagrant.cloud_init.incorrect_content_type",
+                           machine: machine.name,
+                           content_type: @content_type,
+                           accepted_types: DEFAULT_CONTENT_TYPES.join(', '))
+        end
+
+        if @path && @inline
+          errors << I18n.t("vagrant.cloud_init.path_and_inline_set",
+                           machine: machine.name)
+        end
+
+        if @path
+          if !@path.is_a?(String)
+            errors << I18n.t("vagrant.cloud_init.incorrect_path_type",
+                              machine: machine.name,
+                              path: @path,
+                              type: @path.class.name)
+          else
+            expanded_path = Pathname.new(@path).expand_path(machine.env.root_path)
+            if !expanded_path.file?
+              errors << I18n.t("vagrant.cloud_init.path_invalid",
+                               path: expanded_path,
+                               machine: machine.name)
+            end
+          end
+        end
+
+        if @inline
+          if !@inline.is_a?(String)
+            errors << I18n.t("vagrant.cloud_init.incorrect_inline_type",
+                             machine: machine.name,
+                             type: @inline.class.name)
+          end
+        end
+
+        errors
+      end
+
+      # The String representation of this config.
+      #
+      # @return [String]
+      def to_s
+        "cloud_init config"
+      end
+    end
+  end
+end

data/plugins/kernel_v2/config/disk.rb

@@ -0,0 +1,224 @@
+# Copyright (c) HashiCorp, Inc.
+# SPDX-License-Identifier: BUSL-1.1
+
+require "log4r"
+require "securerandom"
+
+require "vagrant/util/numeric"
+
+module VagrantPlugins
+  module Kernel_V2
+    class VagrantConfigDisk < Vagrant.plugin("2", :config)
+      #-------------------------------------------------------------------
+      # Config class for a given Disk
+      #-------------------------------------------------------------------
+
+      DEFAULT_DISK_TYPES = [:disk, :dvd, :floppy].freeze
+
+      FILE_CHAR_REGEX = /[^-a-z0-9_]/i.freeze
+
+      # Note: This value is for internal use only
+      #
+      # @return [String]
+      attr_reader :id
+
+      # File name for the given disk. Defaults to a generated name that is:
+      #
+      #  vagrant_<disk_type>_<short_uuid>
+      #
+      # @return [String]
+      attr_accessor :name
+
+      # Type of disk to create. Defaults to `:disk`
+      #
+      # @return [Symbol]
+      attr_accessor :type
+
+      # Type of disk extension to create. Defaults to `vdi`
+      #
+      # @return [String]
+      attr_accessor :disk_ext
+
+      # Size of disk to create
+      #
+      # @return [Integer,String]
+      attr_accessor :size
+
+      # Path to the location of the disk file (Optional for `:disk` type,
+      # required for `:dvd` type.)
+      #
+      # @return [String]
+      attr_accessor :file
+
+      # Determines if this disk is the _main_ disk, or an attachment.
+      # Defaults to true.
+      #
+      # @return [Boolean]
+      attr_accessor :primary
+
+      # Provider specific options
+      #
+      # @return [Hash]
+      attr_accessor :provider_config
+
+      def initialize(type)
+        @logger = Log4r::Logger.new("vagrant::config::vm::disk")
+
+        @type = type
+        @provider_config = {}
+
+        @name = UNSET_VALUE
+        @provider_type = UNSET_VALUE
+        @size = UNSET_VALUE
+        @primary = UNSET_VALUE
+        @file = UNSET_VALUE
+        @disk_ext = UNSET_VALUE
+
+        # Internal options
+        @id = SecureRandom.uuid
+      end
+
+      # Helper method for storing provider specific config options
+      #
+      # Expected format is:
+      #
+      # - `provider__diskoption: value`
+      # - `{provider: {diskoption: value, otherdiskoption: value, ...}`
+      #
+      # Duplicates will be overriden
+      #
+      # @param [Hash] options
+      def add_provider_config(**options, &block)
+        current = {}
+        options.each do |k,v|
+          opts = k.to_s.split("__")
+
+          if opts.size == 2
+            current[opts[0].to_sym] = {opts[1].to_sym => v}
+          elsif v.is_a?(Hash)
+            current[k] = v
+          else
+            @logger.warn("Disk option '#{k}' found that does not match expected provider disk config schema.")
+          end
+        end
+
+        current = @provider_config.merge(current) if !@provider_config.empty?
+        if current
+          @provider_config = current
+        else
+          @provider_config = {}
+        end
+      end
+
+      def finalize!
+        # Ensure all config options are set to nil or default value if untouched
+        # by user
+        @type = :disk if @type == UNSET_VALUE
+        @size = nil if @size == UNSET_VALUE
+        @file = nil if @file == UNSET_VALUE
+
+        if @primary == UNSET_VALUE
+          @primary = false
+        end
+
+        if @name.is_a?(String) && @name.match(FILE_CHAR_REGEX)
+            @logger.warn("Vagrant will remove detected invalid characters in '#{@name}' and convert the disk name into something usable for a file")
+            @name.gsub!(FILE_CHAR_REGEX, "_")
+        elsif @name == UNSET_VALUE
+          if @primary
+            @name = "vagrant_primary"
+          else
+            @name = nil
+          end
+        end
+      end
+
+      # @return [Array] array of strings of error messages from config option validation
+      def validate(machine)
+        errors = _detected_errors
+        # validate type with list of known disk types
+
+        if !DEFAULT_DISK_TYPES.include?(@type)
+          errors << I18n.t("vagrant.config.disk.invalid_type", type: @type,
+                           types: DEFAULT_DISK_TYPES.join(', '))
+        end
+
+        if @disk_ext == UNSET_VALUE
+          if machine.provider.capability?(:set_default_disk_ext)
+            @disk_ext = machine.provider.capability(:set_default_disk_ext)
+          else
+            @logger.warn("No provider capability defined to set default 'disk_ext' type. Will use 'vdi' for disk extension.")
+            @disk_ext = "vdi"
+          end
+        elsif @disk_ext
+          @disk_ext = @disk_ext.downcase
+
+          if machine.provider.capability?(:validate_disk_ext)
+            if !machine.provider.capability(:validate_disk_ext, @disk_ext)
+              if machine.provider.capability?(:default_disk_exts)
+                disk_exts = machine.provider.capability(:default_disk_exts).join(', ')
+              else
+                disk_exts = "not found"
+              end
+              errors << I18n.t("vagrant.config.disk.invalid_ext", ext: @disk_ext,
+                               name: @name,
+                               exts: disk_exts)
+            end
+          else
+            @logger.warn("No provider capability defined to validate 'disk_ext' type")
+          end
+        end
+
+        if @size && !@size.is_a?(Integer)
+          if @size.is_a?(String)
+            @size = Vagrant::Util::Numeric.string_to_bytes(@size)
+          end
+        end
+
+        if !@size && type == :disk
+          errors << I18n.t("vagrant.config.disk.invalid_size", name: @name, machine: machine.name)
+        end
+
+        if @type == :dvd && !@file
+          errors << I18n.t("vagrant.config.disk.dvd_type_file_required", name: @name, machine: machine.name)
+        end
+
+        if @type == :dvd && @primary
+          errors << I18n.t("vagrant.config.disk.dvd_type_primary", name: @name, machine: machine.name)
+        end
+
+        if @file
+          if !@file.is_a?(String)
+            errors << I18n.t("vagrant.config.disk.invalid_file_type", file: @file, machine: machine.name)
+          elsif !File.file?(@file)
+            errors << I18n.t("vagrant.config.disk.missing_file", file_path: @file,
+                             name: @name, machine: machine.name)
+          end
+        end
+
+        if @provider_config
+          if !@provider_config.empty?
+            if !@provider_config.key?(machine.provider_name)
+              machine.env.ui.warn(I18n.t("vagrant.config.disk.missing_provider",
+                                         machine: machine.name,
+                                         provider_name: machine.provider_name))
+            end
+          end
+        end
+
+        if !@name
+          errors << I18n.t("vagrant.config.disk.no_name_set", machine: machine.name)
+        end
+
+        errors
+      end
+
+      # The String representation of this Disk.
+      #
+      # @return [String]
+      def to_s
+        "disk config"
+      end
+    end
+  end
+end

data/plugins/kernel_v2/config/package.rb

@@ -0,0 +1,24 @@
+# Copyright (c) HashiCorp, Inc.
+# SPDX-License-Identifier: BUSL-1.1
+
+require "vagrant"
+
+module VagrantPlugins
+  module Kernel_V2
+    class PackageConfig < Vagrant.plugin("2", :config)
+      attr_accessor :name
+
+      def initialize
+        @name = UNSET_VALUE
+      end
+
+      def finalize!
+        @name = nil if @name == UNSET_VALUE
+      end
+
+      def to_s
+        "Package"
+      end
+    end
+  end
+end

data/plugins/kernel_v2/config/push.rb

@@ -0,0 +1,155 @@
+# Copyright (c) HashiCorp, Inc.
+# SPDX-License-Identifier: BUSL-1.1
+
+require "vagrant"
+
+module VagrantPlugins
+  module Kernel_V2
+    class PushConfig < Vagrant.plugin("2", :config)
+      VALID_OPTIONS = [:strategy].freeze
+
+      attr_accessor :name
+
+      def initialize
+        @logger = Log4r::Logger.new("vagrant::config::push")
+
+        # Internal state
+        @__defined_pushes  = {}
+        @__compiled_pushes = {}
+        @__finalized       = false
+      end
+
+      def finalize!
+        @logger.debug("finalizing")
+
+        # Compile all the provider configurations
+        @__defined_pushes.each do |name, tuples|
+          # Capture the strategy so we can use it later. This will be used in
+          # the block iteration for merging/overwriting
+          strategy = name
+          strategy = tuples[0][0] if tuples[0]
+
+          # Find the configuration class for this push
+          config_class = Vagrant.plugin("2").manager.push_configs[strategy]
+          config_class ||= Vagrant::Config::V2::DummyConfig
+
+          # Load it up
+          config = config_class.new
+
+          begin
+            tuples.each do |s, b|
+              # Update the strategy if it has changed, resetting the current
+              # config object.
+              if s != strategy
+                @logger.warn("duplicate strategy defined, overwriting config")
+                strategy = s
+                config = config_class.new
+              end
+
+              # If we don't have any blocks, then ignore it
+              next if b.nil?
+
+              new_config = config_class.new
+              b.call(new_config, Vagrant::Config::V2::DummyConfig.new)
+              config = config.merge(new_config)
+            end
+          rescue Exception => e
+            raise Vagrant::Errors::VagrantfileLoadError,
+              path: "<push config: #{name}>",
+              message: e.message
+          end
+
+          config.finalize!
+          # It's important that we call _finalize! here also, because pushes get
+          # plucked out of the config in Environment#push without the larger
+          # root.finalize! walk having been done. This means that push configs
+          # were coming out unfinalized, which can cause havoc when they're
+          # passed through functions that attempt to capture keyword arguments,
+          # as they'll cause ruby to call .to_hash on the config, get a
+          # DummyConfig, and then blow up. That havoc was happening in server
+          # mode, and this call fixes it.
+          config._finalize!
+
+          # Store it for retrieval later
+          @__compiled_pushes[name] = [strategy, config]
+        end
+
+        @__finalized = true
+      end
+
+      # Define a new push in the Vagrantfile with the given name.
+      #
+      # @example
+      #   vm.push.define "ftp"
+      #
+      # @example
+      #   vm.push.define "ftp" do |s|
+      #     s.host = "..."
+      #   end
+      #
+      # @example
+      #   vm.push.define "production", strategy: "docker" do |s|
+      #     # ...
+      #   end
+      #
+      # @param [#to_sym] name The name of the this strategy. By default, this
+      #   is also the name of the strategy, but the `:strategy` key can be given
+      #   to customize this behavior
+      # @param [Hash] options The list of options
+      #
+      def define(name, **options, &block)
+        name = name.to_sym
+        strategy = options[:strategy] || name
+
+        @__defined_pushes[name] ||= []
+        @__defined_pushes[name] << [strategy.to_sym, block]
+      end
+
+      # The String representation of this Push.
+      #
+      # @return [String]
+      def to_s
+        "Push"
+      end
+
+      # Custom merge method
+      def merge(other)
+        super.tap do |result|
+          other_pushes = other.instance_variable_get(:@__defined_pushes)
+          new_pushes   = @__defined_pushes.dup
+
+          other_pushes.each do |key, tuples|
+            new_pushes[key] ||= []
+            new_pushes[key] += tuples
+          end
+
+          result.instance_variable_set(:@__defined_pushes, new_pushes)
+        end
+      end
+
+      # Validate all pushes
+      def validate(machine)
+        errors = { "push" => _detected_errors }
+
+        __compiled_pushes.each do |_, push|
+          config = push[1]
+          push_errors = config.validate(machine)
+
+          if push_errors
+            errors = Vagrant::Config::V2::Util.merge_errors(errors, push_errors)
+          end
+        end
+
+        errors
+      end
+
+      # This returns the list of compiled pushes as a hash by name.
+      #
+      # @return [Hash<Symbol, Array<Class, Object>>]
+      def __compiled_pushes
+        raise "Must finalize first!" if !@__finalized
+        @__compiled_pushes.dup
+      end
+    end
+  end
+end

data/plugins/kernel_v2/config/ssh.rb

@@ -0,0 +1,93 @@
+# Copyright (c) HashiCorp, Inc.
+# SPDX-License-Identifier: BUSL-1.1
+
+require "vagrant"
+
+require_relative "ssh_connect"
+
+module VagrantPlugins
+  module Kernel_V2
+    class SSHConfig < SSHConnectConfig
+      attr_accessor :forward_agent
+      attr_accessor :forward_x11
+      attr_accessor :forward_env
+      attr_accessor :guest_port
+      attr_accessor :keep_alive
+      attr_accessor :shell
+      attr_accessor :proxy_command
+      attr_accessor :ssh_command
+      attr_accessor :pty
+      attr_accessor :sudo_command
+      attr_accessor :export_command_template
+
+      attr_reader :default
+
+      def initialize
+        super
+
+        @forward_agent           = UNSET_VALUE
+        @forward_x11             = UNSET_VALUE
+        @forward_env             = UNSET_VALUE
+        @guest_port              = UNSET_VALUE
+        @keep_alive              = UNSET_VALUE
+        @proxy_command           = UNSET_VALUE
+        @ssh_command             = UNSET_VALUE
+        @pty                     = UNSET_VALUE
+        @shell                   = UNSET_VALUE
+        @sudo_command            = UNSET_VALUE
+        @export_command_template = UNSET_VALUE
+        @default                 = SSHConnectConfig.new
+      end
+
+      def merge(other)
+        super.tap do |result|
+          merged_defaults = @default.merge(other.default)
+          result.instance_variable_set(:@default, merged_defaults)
+        end
+      end
+
+      def finalize!
+        super
+
+        @forward_agent = false if @forward_agent == UNSET_VALUE
+        @forward_x11   = false if @forward_x11 == UNSET_VALUE
+        @forward_env   = false if @forward_env == UNSET_VALUE
+        @guest_port = 22 if @guest_port == UNSET_VALUE
+        @keep_alive = true if @keep_alive == UNSET_VALUE
+        @proxy_command = nil if @proxy_command == UNSET_VALUE
+        @ssh_command = nil if @ssh_command == UNSET_VALUE
+        @pty        = false if @pty == UNSET_VALUE
+        @shell      = "bash -l" if @shell == UNSET_VALUE
+
+        if @export_command_template == UNSET_VALUE
+          @export_command_template = 'export %ENV_KEY%="%ENV_VALUE%"'
+        end
+
+        if @sudo_command == UNSET_VALUE
+          @sudo_command = "sudo -E -H %c"
+        end
+
+        @default.username = "vagrant" if @default.username == UNSET_VALUE
+        @default.port     = @guest_port if @default.port == UNSET_VALUE
+        @default.finalize!
+      end
+
+      def to_s
+        "SSH"
+      end
+
+      def validate(machine)
+        errors = super
+
+        # Return the errors
+        result = { to_s => errors }
+
+        # Figure out the errors for the defaults
+        default_errors = @default.validate(machine)
+        result["SSH Defaults"] = default_errors if !default_errors.empty?
+
+        result
+      end
+    end
+  end
+end