vagrant-unbundled 2.2.7.0 → 2.2.16.0

data/lib/vagrant/cli.rb

@@ -62,9 +62,11 @@ module Vagrant
       # Initialize and execute the command class, returning the exit status.
       result = 0
       begin
-        @triggers.fire_triggers(@sub_command.to_sym, :before, nil, :command) if Vagrant::Util::Experimental.feature_enabled?("typed_triggers")
+        @triggers.fire(@sub_command, :before, nil, :command) if
+          Vagrant::Util::Experimental.feature_enabled?("typed_triggers")
         result = command_class.new(@sub_args, @env).execute
-        @triggers.fire_triggers(@sub_command.to_sym, :after, nil, :command) if Vagrant::Util::Experimental.feature_enabled?("typed_triggers")
+        @triggers.fire(@sub_command, :after, nil, :command) if
+          Vagrant::Util::Experimental.feature_enabled?("typed_triggers")
       rescue Interrupt
         @env.ui.info(I18n.t("vagrant.cli_interrupt"))
         result = 1

data/lib/vagrant/environment.rb

@@ -517,6 +517,7 @@ module Vagrant
     # @param [Action::Runner] action_runner A custom action runner for running hooks.
     def hook(name, opts=nil)
       @logger.info("Running hook: #{name}")
+
       opts ||= {}
       opts[:callable] ||= Action::Builder.new
       opts[:runner] ||= action_runner

data/lib/vagrant/errors.rb

@@ -100,7 +100,7 @@ module Vagrant
 
       def translate_error(opts)
         return nil if !opts[:_key]
-        I18n.t("#{opts[:_namespace]}.#{opts[:_key]}", opts)
+        I18n.t("#{opts[:_namespace]}.#{opts[:_key]}", **opts)
       end
     end
 
@@ -248,6 +248,10 @@ module Vagrant
       error_key(:bundler_error)
     end
 
+    class SourceSpecNotFound < BundlerError
+      error_key(:source_spec_not_found)
+    end
+
     class CantReadMACAddresses < VagrantError
       error_key(:cant_read_mac_addresses)
     end
@@ -300,6 +304,14 @@ module Vagrant
       error_key(:clone_machine_not_found)
     end
 
+    class CloudInitNotFound < VagrantError
+      error_key(:cloud_init_not_found)
+    end
+
+    class CloudInitCommandFailed < VagrantError
+      error_key(:cloud_init_command_failed)
+    end
+
     class CommandDeprecated < VagrantError
       error_key(:command_deprecated)
     end
@@ -336,6 +348,10 @@ module Vagrant
       error_key(:corrupt_machine_index)
     end
 
+    class CreateIsoHostCapNotFound < VagrantError
+      error_key(:create_iso_host_cap_not_found)
+    end
+
     class DarwinMountFailed < VagrantError
       error_key(:darwin_mount_failed)
     end
@@ -396,6 +412,10 @@ module Vagrant
       error_key(:auto_empty, "vagrant.actions.vm.forward_ports")
     end
 
+    class ForwardPortHostIPNotFound < VagrantError
+      error_key(:host_ip_not_found, "vagrant.actions.vm.forward_ports")
+    end
+
     class ForwardPortCollision < VagrantError
       error_key(:collision_error, "vagrant.actions.vm.forward_ports")
     end
@@ -420,6 +440,10 @@ module Vagrant
       error_key(:host_explicit_not_detected)
     end
 
+    class ISOBuildFailed < VagrantError
+      error_key(:iso_build_failed)
+    end
+
     class LinuxMountFailed < VagrantError
       error_key(:linux_mount_failed)
     end
@@ -460,6 +484,10 @@ module Vagrant
       error_key(:multi_vm_target_required)
     end
 
+    class NetplanNoAvailableRenderers < VagrantError
+      error_key(:netplan_no_available_renderers)
+    end
+
     class NetSSHException < VagrantError
       error_key(:net_ssh_exception)
     end
@@ -608,6 +636,18 @@ module Vagrant
       error_key(:provisioner_winrm_unsupported)
     end
 
+    class PluginNeedsDeveloperTools < VagrantError
+      error_key(:plugin_needs_developer_tools)
+    end
+
+    class PluginMissingLibrary < VagrantError
+      error_key(:plugin_missing_library)
+    end
+
+    class PluginMissingRubyDev < VagrantError
+      error_key(:plugin_missing_ruby_dev)
+    end
+
     class PluginGemNotFound < VagrantError
       error_key(:plugin_gem_not_found)
     end
@@ -616,6 +656,10 @@ module Vagrant
       error_key(:plugin_install_license_not_found)
     end
 
+    class PluginInstallFailed < VagrantError
+      error_key(:plugin_install_failed)
+    end
+
     class PluginInstallSpace < VagrantError
       error_key(:plugin_install_space)
     end
@@ -780,6 +824,10 @@ module Vagrant
       error_key(:ssh_key_type_not_supported)
     end
 
+    class SSHNoExitStatus < VagrantError
+      error_key(:ssh_no_exit_status)
+    end
+
     class SSHNoRoute < VagrantError
       error_key(:ssh_no_route)
     end
@@ -904,6 +952,26 @@ module Vagrant
       error_key(:virtualbox_broken_version_040214)
     end
 
+    class VirtualBoxDisksDefinedExceedLimit < VagrantError
+      error_key(:virtualbox_disks_defined_exceed_limit)
+    end
+
+    class VirtualBoxDisksControllerNotFound < VagrantError
+      error_key(:virtualbox_disks_controller_not_found)
+    end
+
+    class VirtualBoxDisksNoSupportedControllers < VagrantError
+      error_key(:virtualbox_disks_no_supported_controllers)
+    end
+
+    class VirtualBoxDisksPrimaryNotFound < VagrantError
+      error_key(:virtualbox_disks_primary_not_found)
+    end
+
+    class VirtualBoxDisksUnsupportedController < VagrantError
+      error_key(:virtualbox_disks_unsupported_controller)
+    end
+
     class VirtualBoxGuestPropertyNotFound < VagrantError
       error_key(:virtualbox_guest_property_not_found)
     end

data/lib/vagrant/machine.rb

@@ -1,4 +1,5 @@
 require_relative "util/ssh"
+require_relative "action/builtin/mixin_synced_folders"
 
 require "digest/md5"
 require "thread"
@@ -10,6 +11,8 @@ module Vagrant
   # API for querying the state and making state changes to the machine, which
   # is backed by any sort of provider (VirtualBox, VMware, etc.).
   class Machine
+    extend Vagrant::Action::Builtin::MixinSyncedFolders
+
     # The box that is backing this machine.
     #
     # @return [Box]
@@ -62,6 +65,11 @@ module Vagrant
     # @return [Hash]
     attr_reader :provider_options
 
+    # The triggers with machine specific configuration applied
+    #
+    # @return [Vagrant::Plugin::V2::Trigger]
+    attr_reader :triggers
+
     # The UI for outputting in the scope of this machine.
     #
     # @return [UI]
@@ -160,8 +168,6 @@ module Vagrant
     #   as extra data set on the environment hash for the middleware
     #   runner.
     def action(name, opts=nil)
-      @triggers.fire_triggers(name, :before, @name.to_s, :action)
-
       @logger.info("Calling action: #{name} on provider #{@provider}")
 
       opts ||= {}
@@ -210,8 +216,6 @@ module Vagrant
         ui.machine("action", name.to_s, "end")
         action_result
       end
-
-      @triggers.fire_triggers(name, :after, @name.to_s, :action)
       # preserve returning environment after machine action runs
       return return_env
     rescue Errors::EnvironmentLockedError
@@ -227,14 +231,18 @@ module Vagrant
     # @param [Proc] callable
     # @param [Hash] extra_env Extra env for the action env.
     # @return [Hash] The resulting env
-    def action_raw(name, callable, extra_env=nil)
+    def action_raw(name, callable, extra_env={})
+      if !extra_env.is_a?(Hash)
+        extra_env = {}
+      end
+
       # Run the action with the action runner on the environment
-      env = {
+      env = {ui: @ui}.merge(extra_env).merge(
+        raw_action_name: name,
         action_name: "machine_action_#{name}".to_sym,
         machine: self,
-        machine_action: name,
-        ui: @ui,
-      }.merge(extra_env || {})
+        machine_action: name
+      )
       @env.action_runner.run(callable, env)
     end
 
@@ -476,8 +484,9 @@ module Vagrant
 
       # We also set some fields that are purely controlled by Vagrant
       info[:forward_agent] = @config.ssh.forward_agent
-      info[:forward_x11]   = @config.ssh.forward_x11
-      info[:forward_env]   = @config.ssh.forward_env
+      info[:forward_x11] = @config.ssh.forward_x11
+      info[:forward_env] = @config.ssh.forward_env
+      info[:connect_timeout] = @config.ssh.connect_timeout
 
       info[:ssh_command] = @config.ssh.ssh_command if @config.ssh.ssh_command
 
@@ -553,6 +562,41 @@ module Vagrant
       result
     end
 
+    # Returns the state of this machine. The state is queried from the
+    # backing provider, so it can be any arbitrary symbol.
+    #
+    # @param [Symbol] state of machine
+    # @return [Entry] entry of recovered machine
+    def recover_machine(state)
+      entry = @env.machine_index.get(index_uuid)
+      if entry
+        @env.machine_index.release(entry)
+        return entry
+      end
+
+      entry = MachineIndex::Entry.new(id=index_uuid, {})
+      entry.local_data_path = @env.local_data_path
+      entry.name = @name.to_s
+      entry.provider = @provider_name.to_s
+      entry.state = state
+      entry.vagrantfile_path = @env.root_path
+      entry.vagrantfile_name = @env.vagrantfile_name
+
+      if @box
+        entry.extra_data["box"] = {
+          "name"     => @box.name,
+          "provider" => @box.provider.to_s,
+          "version"  => @box.version.to_s,
+        }
+      end
+
+      @state_mutex.synchronize do
+        entry = @env.machine_index.recover(entry)
+        @env.machine_index.release(entry)
+      end
+      return entry
+    end
+
     # Returns the user ID that created this machine. This is specific to
     # the host machine that this was created on.
     #
@@ -578,6 +622,15 @@ module Vagrant
       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
+      self.class.synced_folders(self)
+    end
+
     protected
 
     # Returns the path to the file that stores the UID.

data/lib/vagrant/machine_index.rb

@@ -231,12 +231,39 @@ module Vagrant
       Entry.new(id, struct)
     end
 
+    # Reinsert a machine into the global index if it has
+    # a valid existing uuid but does not currently exist
+    # in the index.
+    #
+    # @param [Entry] entry
+    # @return [Entry]
+    def recover(entry)
+      @lock.synchronize do
+        with_index_lock do
+          # Reload the data
+          unlocked_reload
+          # Don't recover if entry already exists in the global
+          return entry if find_by_prefix(entry.id)
+
+          lock_file = lock_machine(entry.id)
+          if !lock_file
+            raise Errors::MachineLocked,
+              name: entry.name,
+              provider: entry.provider
+          end
+          @machine_locks[entry.id] = lock_file
+        end
+      end
+      return set(entry)
+    end
+
     protected
 
     # Finds a machine where the UUID is prefixed by the given string.
     #
     # @return [Hash]
     def find_by_prefix(prefix)
+      return if !prefix || prefix == ""
       @machines.each do |uuid, data|
         return data.merge("id" => uuid) if uuid.start_with?(prefix)
       end
@@ -452,7 +479,7 @@ module Vagrant
       # Creates a {Vagrant::Environment} for this entry.
       #
       # @return [Vagrant::Environment]
-      def vagrant_env(home_path, **opts)
+      def vagrant_env(home_path, opts={})
         Vagrant::Util::SilenceWarnings.silence! do
           Environment.new({
             cwd: @vagrantfile_path,

data/lib/vagrant/patches/net-ssh.rb

@@ -0,0 +1,186 @@
+require "net/ssh"
+
+# Only patch if we have version 6.1.0 loaded as
+# these patches pull 6.1.0 up to the as of now
+# current 6.2.0 beta
+if Net::SSH::Version::STRING == "6.1.0"
+  require "net/ssh/authentication/methods/publickey"
+  Net::SSH::Authentication::Methods::Publickey.class_eval do
+    def rsa_compat_build_request(pub_key, *args)
+      s_ver_str = session.transport.server_version.version.match(/OpenSSH_(?<version>\d+\.\d+)/)[:version]
+      begin
+        s_ver = Gem::Version.new(s_ver_str)
+        if s_ver >= Gem::Version.new("7.2") && pub_key.is_a?(OpenSSL::PKey::RSA)
+          pub_key.deprecated_ssh_rsa = true
+          debug { "public key has been marked for deprecated ssh-rsa SHA1 behavior" }
+          info = key_manager.known_identities[pub_key]
+          if info && info[:key]
+            info[:key].deprecated_ssh_rsa = true
+            debug { "private key has been marked for deprecated ssh-rsa SHA1 behavior" }
+          else
+            warn { "cannot deprecate ssh rsa on private key, not loaded (#{info[:file]})" }
+          end
+        end
+      rescue ArgumentError
+        warn { "failed to parse OpenSSH version (raw: #{session.transport.server_version.version} attempted: #{s_ver_str}" }
+      end
+      _raw_build_request(pub_key, *args)
+    end
+    alias_method :_raw_build_request, :build_request
+    alias_method :build_request, :rsa_compat_build_request
+  end
+
+  require "net/ssh/authentication/agent"
+  # net/ssh/authentication/agent
+  Net::SSH::Authentication::Agent.class_eval do
+    SSH2_AGENT_LOCK = 22
+    SSH2_AGENT_UNLOCK = 23
+
+    # lock the ssh agent with password
+    def lock(password)
+      type, = send_and_wait(SSH2_AGENT_LOCK, :string, password)
+      raise AgentError, "could not lock agent" if type != SSH_AGENT_SUCCESS
+    end
+
+    # unlock the ssh agent with password
+    def unlock(password)
+      type, = send_and_wait(SSH2_AGENT_UNLOCK, :string, password)
+      raise AgentError, "could not unlock agent" if type != SSH_AGENT_SUCCESS
+    end
+  end
+
+  require "net/ssh/authentication/certificate"
+  # net/ssh/authentication/certificate
+  Net::SSH::Authentication::Certificate.class_eval do
+    def ssh_do_verify(sig, data, options = {})
+      key.ssh_do_verify(sig, data, options)
+    end
+  end
+
+  require "net/ssh/authentication/ed25519"
+  # net/ssh/authentication/ed25519
+  Net::SSH::Authentication::ED25519::PubKey.class_eval do
+    def ssh_do_verify(sig, data, options = {})
+      @verify_key.verify(sig,data)
+    end
+  end
+
+  require "net/ssh/transport/algorithms"
+  # net/ssh/transport/algorithms
+  Net::SSH::Transport::Algorithms::DEFAULT_ALGORITHMS[:host_key].push("rsa-sha2-256").push("rsa-sha2-512")
+
+  require "net/ssh/transport/cipher_factory"
+  # net/ssh/transport/cipher_factory
+  Net::SSH::Transport::CipherFactory::SSH_TO_OSSL["aes256-ctr"] = ::OpenSSL::Cipher.ciphers.include?("aes-256-ctr") ? "aes-256-ctr" : "aes-256-ecb"
+  Net::SSH::Transport::CipherFactory::SSH_TO_OSSL["aes192-ctr"] = ::OpenSSL::Cipher.ciphers.include?("aes-192-ctr") ? "aes-192-ctr" : "aes-192-ecb"
+  Net::SSH::Transport::CipherFactory::SSH_TO_OSSL["aes128-ctr"] = ::OpenSSL::Cipher.ciphers.include?("aes-128-ctr") ? "aes-128-ctr" : "aes-128-ecb"
+
+  require "net/ssh/transport/kex/abstract"
+  # net/ssh/transport/kex/abstract
+  Net::SSH::Transport::Kex::Abstract.class_eval do
+    def matching?(key_ssh_type, host_key_alg)
+      return true if key_ssh_type == host_key_alg
+      return true if key_ssh_type == 'ssh-rsa' && ['rsa-sha2-512', 'rsa-sha2-256'].include?(host_key_alg)
+    end
+
+    def verify_server_key(key) #:nodoc:
+      unless matching?(key.ssh_type, algorithms.host_key)
+        raise Net::SSH::Exception, "host key algorithm mismatch '#{key.ssh_type}' != '#{algorithms.host_key}'"
+      end
+
+      blob, fingerprint = generate_key_fingerprint(key)
+
+      unless connection.host_key_verifier.verify(key: key, key_blob: blob, fingerprint: fingerprint, session: connection)
+        raise Net::SSH::Exception, 'host key verification failed'
+      end
+    end
+
+    def verify_signature(result) #:nodoc:
+      response = build_signature_buffer(result)
+
+      hash = digester.digest(response.to_s)
+
+      server_key = result[:server_key]
+      server_sig = result[:server_sig]
+      unless connection.host_key_verifier.verify_signature { server_key.ssh_do_verify(server_sig, hash, host_key: algorithms.host_key) }
+        raise Net::SSH::Exception, 'could not verify server signature'
+      end
+
+      hash
+    end
+  end
+
+  require "net/ssh/transport/openssl"
+  # net/ssh/transport/openssl
+  OpenSSL::PKey::RSA.class_eval do
+    attr_accessor :deprecated_ssh_rsa
+
+    def ssh_do_verify(sig, data, options = {})
+      digester =
+        if options[:host_key] == "rsa-sha2-512"
+          OpenSSL::Digest::SHA512.new
+        elsif options[:host_key] == "rsa-sha2-256"
+          OpenSSL::Digest::SHA256.new
+        else
+          OpenSSL::Digest::SHA1.new
+        end
+
+      verify(digester, sig, data)
+    end
+
+    def ssh_type
+      deprecated_ssh_rsa ? signature_algorithm : "ssh-rsa"
+    end
+
+    def signature_algorithm
+      "rsa-sha2-256"
+    end
+
+    def ssh_do_sign(data)
+      if deprecated_ssh_rsa
+        sign(OpenSSL::Digest::SHA256.new, data)
+      else
+        sign(OpenSSL::Digest::SHA1.new, data)
+      end
+    end
+  end
+
+  OpenSSL::PKey::DSA.class_eval do
+    def ssh_do_verify(sig, data, options = {})
+      sig_r = sig[0,20].unpack("H*")[0].to_i(16)
+      sig_s = sig[20,20].unpack("H*")[0].to_i(16)
+      a1sig = OpenSSL::ASN1::Sequence([
+        OpenSSL::ASN1::Integer(sig_r),
+        OpenSSL::ASN1::Integer(sig_s)
+      ])
+      return verify(OpenSSL::Digest::SHA1.new, a1sig.to_der, data)
+    end
+  end
+
+  OpenSSL::PKey::EC.class_eval do
+    def ssh_do_verify(sig, data, options = {})
+      digest = digester.digest(data)
+      a1sig = nil
+
+      begin
+        sig_r_len = sig[0, 4].unpack('H*')[0].to_i(16)
+        sig_l_len = sig[4 + sig_r_len, 4].unpack('H*')[0].to_i(16)
+
+        sig_r = sig[4, sig_r_len].unpack('H*')[0]
+        sig_s = sig[4 + sig_r_len + 4, sig_l_len].unpack('H*')[0]
+
+        a1sig = OpenSSL::ASN1::Sequence([
+          OpenSSL::ASN1::Integer(sig_r.to_i(16)),
+          OpenSSL::ASN1::Integer(sig_s.to_i(16))
+        ])
+      rescue StandardError
+      end
+
+      if a1sig.nil?
+        return false
+      else
+        dsa_verify_asn1(digest, a1sig.to_der)
+      end
+    end
+  end
+end